
;
;
;     Model statements for module:  Create 4
;

490$          CREATE,        1,MinutesToBaseTime(0.0001),Entity rb1rec# c1:MinutesToBaseTime(1440):NEXT(491$);

491$          ASSIGN:        Create for receiving b shift1 c1.NumberOut=Create for receiving b shift1 c1.NumberOut + 1:NEXT(94$);


;
;
;     Model statements for module:  Decide 98
;
94$           BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),494$,Yes:
                             Else,495$,Yes;
494$          ASSIGN:        Decide 98.NumberOut True=Decide 98.NumberOut True + 1:NEXT(488$);

495$          ASSIGN:        Decide 98.NumberOut False=Decide 98.NumberOut False + 1:NEXT(95$);


;
;
;     Model statements for module:  Assign 198
;
488$          ASSIGN:        receiptb1# c1=
                             disc(0.924,0,0.929,1,0.940,2,0.946,6,0.951,8,0.962,9,0.973,15,0.978,16,0.984,17,0.989,18,0.995,19,1,21,67)
                             :NEXT(96$);


;
;
;     Model statements for module:  Decide 99
;
96$           BRANCH,        1:
                             If,receiptb1# c1==0,74$,Yes:
                             If,receiptb1# c1==1,97$,Yes:
                             Else,98$,Yes;

;
;
;     Model statements for module:  Separate 5
;
98$           DUPLICATE,     100 - 50:
                             receiptb1# c1-1,500$,50:NEXT(499$);

499$          ASSIGN:        Separate 5.NumberOut Orig=Separate 5.NumberOut Orig + 1:NEXT(97$);

500$          ASSIGN:        Separate 5.NumberOut Dup=Separate 5.NumberOut Dup + 1:NEXT(97$);


;
;
;     Model statements for module:  Process 10
;
97$           ASSIGN:        Process 10.NumberIn=Process 10.NumberIn + 1:
                             Process 10.WIP=Process 10.WIP+1;
530$          STACK,         1:Save:NEXT(504$);

504$          QUEUE,         Process 10.Queue;
503$          SEIZE,         2,VA:
                             Resource 4_1,1:NEXT(502$);

502$          DELAY:         HoursToBaseTime(expo(10/receiptb1# c1,3)),,VA:NEXT(545$);

545$          ASSIGN:        Process 10.WaitTime=Process 10.WaitTime + Diff.WaitTime;
509$          TALLY:         Process 10.WaitTimePerEntity,Diff.WaitTime,1;
511$          TALLY:         Process 10.TotalTimePerEntity,Diff.StartTime,1;
535$          ASSIGN:        Process 10.VATime=Process 10.VATime + Diff.VATime;
536$          TALLY:         Process 10.VATimePerEntity,Diff.VATime,1;
501$          RELEASE:       Resource 4_1,1;
550$          STACK,         1:Destroy:NEXT(549$);

549$          ASSIGN:        Process 10.NumberOut=Process 10.NumberOut + 1:
                             Process 10.WIP=Process 10.WIP-1:NEXT(66$);


;
;
;     Model statements for module:  Assign 57
;
66$           ASSIGN:        producttype=2:NEXT(157$);


;
;
;     Model statements for module:  Decide 121
;
157$          BRANCH,        1:
                             If,producttype==1,156$,Yes:
                             If,producttype==2,158$,Yes:
                             Else,159$,Yes;
159$          COUNT:         receiptctruck,1:NEXT(150$);


;
;
;     Model statements for module:  Assign 78
;
150$          ASSIGN:        receiptqenter=tnow:NEXT(148$);

148$          QUEUE,         receiptdockqueue;
140$          SEIZE,         2,Other:
                             dock1,1:NEXT(151$);

151$          TALLY:         time in receiptq at d1,tnow-receiptqenter,1:NEXT(1$);


;
;
;     Model statements for module:  Assign 2
;
1$            ASSIGN:        truckcap=8:
                             dockno=1:NEXT(2$);

2$            DUPLICATE:     truckcap-1,50$:NEXT(50$);


;
;
;     Model statements for module:  Process 1
;
50$           ASSIGN:        Unloading from dock1.NumberIn=Unloading from dock1.NumberIn + 1:
                             Unloading from dock1.WIP=Unloading from dock1.WIP+1;
583$          STACK,         1:Save:NEXT(557$);

557$          QUEUE,         Unloading from dock1.Queue;
556$          SEIZE,         1,VA:
                             SELECT(TransSet4,SNB, ),1:NEXT(555$);

555$          DELAY:         SecondsToBaseTime(UNIF(62,83,61)),,VA:NEXT(598$);

598$          ASSIGN:        Unloading from dock1.WaitTime=Unloading from dock1.WaitTime + Diff.WaitTime;
562$          TALLY:         Unloading from dock1.WaitTimePerEntity,Diff.WaitTime,1;
564$          TALLY:         Unloading from dock1.TotalTimePerEntity,Diff.StartTime,1;
588$          ASSIGN:        Unloading from dock1.VATime=Unloading from dock1.VATime + Diff.VATime;
589$          TALLY:         Unloading from dock1.VATimePerEntity,Diff.VATime,1;
554$          RELEASE:       SELECT(TransSet4,LAST),1;
603$          STACK,         1:Destroy:NEXT(602$);

602$          ASSIGN:        Unloading from dock1.NumberOut=Unloading from dock1.NumberOut + 1:
                             Unloading from dock1.WIP=Unloading from dock1.WIP-1:NEXT(261$);


;
;
;     Model statements for module:  Assign 110
;
261$          ASSIGN:        beginning time for putaway from d1=tnow:NEXT(142$);

142$          ASSIGN:        product3stock=(producttype==3)*(product3stock+1)+(producttype<>3)*(product3stock+0):
                             product2stock=(producttype==2)*(product2stock+1)+(producttype<>2)*(product2stock+0):
                             product1stock=(producttype==1)*(product1stock+1)+(producttype<>1)*(product1stock+0);
144$          WRITE,         stockr:
                             totalstock,
                             tnow:NEXT(3$);


;
;
;     Model statements for module:  Assign 3
;
3$            ASSIGN:        i=1:NEXT(4$);


;
;
;     Model statements for module:  Assign 4
;
4$            ASSIGN:        replaced=0:NEXT(5$);

5$            WHILE:         (replaced==0):NEXT(8$);


;
;
;     Model statements for module:  Decide 3
;
8$            BRANCH,        1:
                             If,(LocationA(i,1) == 0) ||  ( (producttype  ==  LocationA (i,2)) && (LocationA(i,1) < Capacity) ),
                             605$,Yes:
                             Else,606$,Yes;
605$          ASSIGN:        Decide 3.NumberOut True=Decide 3.NumberOut True + 1:NEXT(7$);

606$          ASSIGN:        Decide 3.NumberOut False=Decide 3.NumberOut False + 1:NEXT(10$);

7$            ASSIGN:        LocationA(i,1)=LocationA(i,1)+1:
                             LocationA(i,2)=producttype:NEXT(11$);


;
;
;     Model statements for module:  Assign 11
;
11$           ASSIGN:        Locationtype=1:NEXT(44$);


;
;
;     Model statements for module:  Decide 45
;
44$           BRANCH,        1:
                             If,dockno==1,607$,Yes:
                             Else,608$,Yes;
607$          ASSIGN:        Decide 45.NumberOut True=Decide 45.NumberOut True + 1:NEXT(459$);

608$          ASSIGN:        Decide 45.NumberOut False=Decide 45.NumberOut False + 1:NEXT(458$);


;
;
;     Model statements for module:  Assign 183
;
459$          ASSIGN:        width1=
                             (LocationA(i,1)==1)*4+(LocationA(i,1)==2)*3+(LocationA(i,1)==3)*2+(LocationA(i,1)==4)*1+(LocationA(i,1)==5)*0:
                             distance1=20+i*1+width1:NEXT(13$);


;
;
;     Model statements for module:  Assign 13
;
13$           ASSIGN:        replaced=1:NEXT(14$);

14$           ENDWHILE:NEXT(16$);


;
;
;     Model statements for module:  Seize 2
;
16$           QUEUE,         Seizing a forklift from forklift set at receving ramp1.Queue;
              SEIZE,         2,Other:
                             SELECT(TransSet1,CYC, trans_no1),1:NEXT(610$);

610$          DELAY:         0.0,,VA:NEXT(478$);


;
;
;     Model statements for module:  Decide 229
;
478$          BRANCH,        1:
                             If,stock exceeded<>1,611$,Yes:
                             Else,612$,Yes;
611$          ASSIGN:        Decide 229.NumberOut True=Decide 229.NumberOut True + 1:NEXT(18$);

612$          ASSIGN:        Decide 229.NumberOut False=Decide 229.NumberOut False + 1:NEXT(479$);


;
;
;     Model statements for module:  Delay 1
;
18$           DELAY:         
                             SecondsToBaseTime((Locationtype==1)*((34.521+(0.915*distance1)+NORM(0,7.3))*2)+(Locationtype==2)*((34.521+(0.915*distance3)+NORM(0,7.3))*2)+(Locationtype==3)*((34.521+(0.915*distance5)+NORM(0,7.3))*2)+(Locationtype==4)*((34.521+(0.915*distance7)+NORM(0,7.3))*2)),,
                             Other:NEXT(19$);

19$           RELEASE:       Member(TransSet1, Trans_No1),1;
262$          TALLY:         time for putaway from d1,tnow-beginning time for putaway from d1,1;
183$          ASSIGN:        #unloaded1=#unloaded1+1:NEXT(20$);


;
;
;     Model statements for module:  Decide 6
;
20$           BRANCH,        1:
                             If,#unloaded1==truckcap,613$,Yes:
                             Else,614$,Yes;
613$          ASSIGN:        Decide 6.NumberOut True=Decide 6.NumberOut True + 1:NEXT(21$);

614$          ASSIGN:        Decide 6.NumberOut False=Decide 6.NumberOut False + 1:NEXT(15$);


;
;
;     Model statements for module:  Release 1
;
21$           RELEASE:       dock1,1:NEXT(160$);

160$          TALLY:         time in system from d1,tnow-receiptqenter,1;
184$          ASSIGN:        #unloaded1=#unloaded1-#unloaded1:NEXT(15$);


;
;
;     Model statements for module:  Dispose 1
;
15$           ASSIGN:        Dispose 1.NumberOut=Dispose 1.NumberOut + 1;
615$          DISPOSE:       Yes;


;
;
;     Model statements for module:  Delay 14
;
479$          DELAY:         SecondsToBaseTime(((34.521+(0.915*averagedistance)+Norm(0,7.3))*2)),,Other:NEXT(19$);


;
;
;     Model statements for module:  Assign 182
;
458$          ASSIGN:        width2=
                             (LocationA(i,1)==1)*4+(LocationA(i,1)==2)*3+(LocationA(i,1)==3)*2+(LocationA(i,1)==4)*1+(LocationA(i,1)==5)*0:
                             distance2=23+i*1+width2:NEXT(13$);


;
;
;     Model statements for module:  Decide 4
;
10$           BRANCH,        1:
                             If,
                             ((LocationB(i,1) == 0) ||  ( (producttype  ==  LocationB (i,2)) && (LocationB(i,1) < Capacity) )),
                             616$,Yes:
                             Else,617$,Yes;
616$          ASSIGN:        Decide 4.NumberOut True=Decide 4.NumberOut True + 1:NEXT(6$);

617$          ASSIGN:        Decide 4.NumberOut False=Decide 4.NumberOut False + 1:NEXT(51$);

6$            ASSIGN:        LocationB(i,1)=LocationB(i,1)+1:
                             LocationB(i,2)=producttype:NEXT(12$);


;
;
;     Model statements for module:  Assign 12
;
12$           ASSIGN:        Locationtype=2:NEXT(460$);


;
;
;     Model statements for module:  Decide 223
;
460$          BRANCH,        1:
                             If,dockno==1,618$,Yes:
                             Else,619$,Yes;
618$          ASSIGN:        Decide 223.NumberOut True=Decide 223.NumberOut True + 1:NEXT(461$);

619$          ASSIGN:        Decide 223.NumberOut False=Decide 223.NumberOut False + 1:NEXT(462$);


;
;
;     Model statements for module:  Assign 184
;
461$          ASSIGN:        width3=
                             (LocationB(i,1)==1)*4+(LocationB(i,1)==2)*3+(LocationB(i,1)==3)*2+(LocationB(i,1)==4)*1+(LocationB(i,1)==5)*0:
                             distance3=20+i*1+width3:NEXT(13$);


;
;
;     Model statements for module:  Assign 186
;
462$          ASSIGN:        width4=
                             (LocationB(i,1)==1)*4+(LocationB(i,1)==2)*3+(LocationB(i,1)==3)*2+(LocationB(i,1)==4)*1+(LocationB(i,1)==5)*0:
                             distance4=23+i*1+width4:NEXT(13$);


;
;
;     Model statements for module:  Decide 67
;
51$           BRANCH,        1:
                             If,((LocationC(i,1) == 0) ||  ( (producttype  ==  LocationC (i,2)) && (LocationC(i,1) < 8) )),620$,
                             Yes:
                             Else,621$,Yes;
620$          ASSIGN:        Decide 67.NumberOut True=Decide 67.NumberOut True + 1:NEXT(52$);

621$          ASSIGN:        Decide 67.NumberOut False=Decide 67.NumberOut False + 1:NEXT(129$);

52$           ASSIGN:        LocationC(i,1)=LocationC(i,1)+1:
                             LocationC(i,2)=producttype:NEXT(53$);


;
;
;     Model statements for module:  Assign 49
;
53$           ASSIGN:        Locationtype=3:NEXT(54$);


;
;
;     Model statements for module:  Decide 68
;
54$           BRANCH,        1:
                             If,dockno==1,622$,Yes:
                             Else,623$,Yes;
622$          ASSIGN:        Decide 68.NumberOut True=Decide 68.NumberOut True + 1:NEXT(55$);

623$          ASSIGN:        Decide 68.NumberOut False=Decide 68.NumberOut False + 1:NEXT(56$);


;
;
;     Model statements for module:  Assign 51
;
55$           ASSIGN:        width5=
                             (LocationC(i,1)==1)*7+(LocationC(i,1)==2)*6+(LocationC(i,1)==3)*5+(LocationC(i,1)==4)*4+(LocationC(i,1)==5)*3+(LocationC(i,1)==6)*2+(LocationC(i,1)==7)*1+(LocationC(i,1)==8)*0:
                             distance5=13+i*1+width5:NEXT(13$);


;
;
;     Model statements for module:  Assign 52
;
56$           ASSIGN:        width6=
                             (LocationC(i,1)==1)*7+(LocationC(i,1)==2)*6+(LocationC(i,1)==3)*5+(LocationC(i,1)==4)*4+(LocationC(i,1)==5)*3+(LocationC(i,1)==6)*2+(LocationC(i,1)==7)*1+(LocationC(i,1)==8)*0:
                             distance6=14+i*1+width6:NEXT(13$);


;
;
;     Model statements for module:  Decide 110
;
129$          BRANCH,        1:
                             If,((LocationD(i,1) == 0) ||  ( (producttype  ==  LocationD (i,2)) && (LocationD(i,1) < 8) )),624$,
                             Yes:
                             Else,625$,Yes;
624$          ASSIGN:        Decide 110.NumberOut True=Decide 110.NumberOut True + 1:NEXT(130$);

625$          ASSIGN:        Decide 110.NumberOut False=Decide 110.NumberOut False + 1:NEXT(9$);

130$          ASSIGN:        LocationD(i,1)=LocationD(i,1)+1:
                             LocationD(i,2)=producttype:NEXT(131$);


;
;
;     Model statements for module:  Assign 76
;
131$          ASSIGN:        Locationtype=4:NEXT(463$);


;
;
;     Model statements for module:  Decide 224
;
463$          BRANCH,        1:
                             If,dockno==1,626$,Yes:
                             Else,627$,Yes;
626$          ASSIGN:        Decide 224.NumberOut True=Decide 224.NumberOut True + 1:NEXT(464$);

627$          ASSIGN:        Decide 224.NumberOut False=Decide 224.NumberOut False + 1:NEXT(465$);


;
;
;     Model statements for module:  Assign 189
;
464$          ASSIGN:        width7=
                             (LocationD(i,1)==1)*7+(LocationD(i,1)==2)*6+(LocationD(i,1)==3)*5+(LocationD(i,1)==4)*4+(LocationD(i,1)==5)*3+(LocationD(i,1)==6)*2+(LocationD(i,1)==7)*1+(LocationD(i,1)==8)*0:
                             distance7=13+i*1+width7:NEXT(13$);


;
;
;     Model statements for module:  Assign 190
;
465$          ASSIGN:        width8=
                             (LocationD(i,1)==1)*7+(LocationD(i,1)==2)*6+(LocationD(i,1)==3)*5+(LocationD(i,1)==4)*4+(LocationD(i,1)==5)*3+(LocationD(i,1)==6)*2+(LocationD(i,1)==7)*1+(LocationD(i,1)==8)*0:
                             distance8=14+i*1+width8:NEXT(13$);


;
;
;     Model statements for module:  Assign 10
;
9$            ASSIGN:        i=i+1:NEXT(476$);


;
;
;     Model statements for module:  Decide 228
;
476$          BRANCH,        1:
                             If,i<=231,628$,Yes:
                             Else,629$,Yes;
628$          ASSIGN:        Decide 228.NumberOut True=Decide 228.NumberOut True + 1:NEXT(14$);

629$          ASSIGN:        Decide 228.NumberOut False=Decide 228.NumberOut False + 1:NEXT(477$);


;
;
;     Model statements for module:  Assign 196
;
477$          ASSIGN:        stock exceeded=1:NEXT(472$);


;
;
;     Model statements for module:  Decide 227
;
472$          BRANCH,        1:
                             If,producttype==1,473$,Yes:
                             If,producttype==2,474$,Yes:
                             Else,475$,Yes;
475$          ASSIGN:        stock3=stock3+1:NEXT(16$);

473$          ASSIGN:        stock1=stock1+1:NEXT(16$);

474$          ASSIGN:        stock2=stock2+1:NEXT(16$);

156$          COUNT:         receiptatruck,1:NEXT(150$);

158$          COUNT:         receiptbtruck,1:NEXT(150$);


;
;
;     Model statements for module:  Dispose 16
;
74$           ASSIGN:        Dispose 16.NumberOut=Dispose 16.NumberOut + 1;
632$          DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 69
;
95$           ASSIGN:        receiptb2# c1=
                             disc(0.929,0,0.935,1,0.946,7,0.957,8,0.967,12,0.973,15,0.978,17,0.984,19,0.989,21,0.995,27,1,28,68)
                             :NEXT(99$);


;
;
;     Model statements for module:  Decide 100
;
99$           BRANCH,        1:
                             If,receiptb2# c1==0,74$,Yes:
                             If,receiptb2# c1==1,100$,Yes:
                             Else,101$,Yes;

;
;
;     Model statements for module:  Separate 6
;
101$          DUPLICATE,     100 - 50:
                             receiptb2# c1-1,637$,50:NEXT(636$);

636$          ASSIGN:        Separate 6.NumberOut Orig=Separate 6.NumberOut Orig + 1:NEXT(100$);

637$          ASSIGN:        Separate 6.NumberOut Dup=Separate 6.NumberOut Dup + 1:NEXT(100$);


;
;
;     Model statements for module:  Process 11
;
100$          ASSIGN:        Process 11.NumberIn=Process 11.NumberIn + 1:
                             Process 11.WIP=Process 11.WIP+1;
667$          STACK,         1:Save:NEXT(641$);

641$          QUEUE,         Process 11.Queue;
640$          SEIZE,         2,VA:
                             Resource 5,1:NEXT(639$);

639$          DELAY:         HoursToBaseTime(expo(14/receiptb2# c1,4)),,VA:NEXT(682$);

682$          ASSIGN:        Process 11.WaitTime=Process 11.WaitTime + Diff.WaitTime;
646$          TALLY:         Process 11.WaitTimePerEntity,Diff.WaitTime,1;
648$          TALLY:         Process 11.TotalTimePerEntity,Diff.StartTime,1;
672$          ASSIGN:        Process 11.VATime=Process 11.VATime + Diff.VATime;
673$          TALLY:         Process 11.VATimePerEntity,Diff.VATime,1;
638$          RELEASE:       Resource 5,1;
687$          STACK,         1:Destroy:NEXT(686$);

686$          ASSIGN:        Process 11.NumberOut=Process 11.NumberOut + 1:
                             Process 11.WIP=Process 11.WIP-1:NEXT(66$);


;
;
;     Model statements for module:  Create 5
;

689$          CREATE,        1,MinutesToBaseTime(0.0001),Entity rc1rec# c1:MinutesToBaseTime(1440):NEXT(690$);

690$          ASSIGN:        Create for receiving c shift1 c1.NumberOut=Create for receiving c shift1 c1.NumberOut + 1
                             :NEXT(102$);


;
;
;     Model statements for module:  Decide 101
;
102$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),693$,Yes:
                             Else,694$,Yes;
693$          ASSIGN:        Decide 101.NumberOut True=Decide 101.NumberOut True + 1:NEXT(103$);

694$          ASSIGN:        Decide 101.NumberOut False=Decide 101.NumberOut False + 1:NEXT(104$);


;
;
;     Model statements for module:  Assign 70
;
103$          ASSIGN:        receiptc1# c1=disc(0.848,0,0.859,1,0.880,2,0.902,3,0.935,4,0.962,5,0.973,6,0.989,7,0.995,8,1,10,69)
                             :NEXT(105$);


;
;
;     Model statements for module:  Decide 102
;
105$          BRANCH,        1:
                             If,receiptc1# c1==0,74$,Yes:
                             If,receiptc1# c1==1,106$,Yes:
                             Else,107$,Yes;

;
;
;     Model statements for module:  Separate 7
;
107$          DUPLICATE,     100 - 50:
                             receiptc1# c1-1,699$,50:NEXT(698$);

698$          ASSIGN:        Separate 7.NumberOut Orig=Separate 7.NumberOut Orig + 1:NEXT(106$);

699$          ASSIGN:        Separate 7.NumberOut Dup=Separate 7.NumberOut Dup + 1:NEXT(106$);


;
;
;     Model statements for module:  Process 12
;
106$          ASSIGN:        Process 12.NumberIn=Process 12.NumberIn + 1:
                             Process 12.WIP=Process 12.WIP+1;
729$          STACK,         1:Save:NEXT(703$);

703$          QUEUE,         Process 12.Queue;
702$          SEIZE,         2,VA:
                             Resource 6,1:NEXT(701$);

701$          DELAY:         HoursToBaseTime(expo(10/receiptc1# c1,5)),,VA:NEXT(744$);

744$          ASSIGN:        Process 12.WaitTime=Process 12.WaitTime + Diff.WaitTime;
708$          TALLY:         Process 12.WaitTimePerEntity,Diff.WaitTime,1;
710$          TALLY:         Process 12.TotalTimePerEntity,Diff.StartTime,1;
734$          ASSIGN:        Process 12.VATime=Process 12.VATime + Diff.VATime;
735$          TALLY:         Process 12.VATimePerEntity,Diff.VATime,1;
700$          RELEASE:       Resource 6,1;
749$          STACK,         1:Destroy:NEXT(748$);

748$          ASSIGN:        Process 12.NumberOut=Process 12.NumberOut + 1:
                             Process 12.WIP=Process 12.WIP-1:NEXT(67$);


;
;
;     Model statements for module:  Assign 58
;
67$           ASSIGN:        producttype=3:NEXT(157$);


;
;
;     Model statements for module:  Assign 71
;
104$          ASSIGN:        receiptc2# c1=disc(0.848,0,0.864,1,0.875,2,0.913,3,0.946,4,0.973,5,0.989,6,0.995,8,1,10,70)
                             :NEXT(108$);


;
;
;     Model statements for module:  Decide 103
;
108$          BRANCH,        1:
                             If,receiptc2# c1==0,74$,Yes:
                             If,receiptc2# c1==1,109$,Yes:
                             Else,110$,Yes;

;
;
;     Model statements for module:  Separate 8
;
110$          DUPLICATE,     100 - 50:
                             receiptc2# c1-1,755$,50:NEXT(754$);

754$          ASSIGN:        Separate 8.NumberOut Orig=Separate 8.NumberOut Orig + 1:NEXT(109$);

755$          ASSIGN:        Separate 8.NumberOut Dup=Separate 8.NumberOut Dup + 1:NEXT(109$);


;
;
;     Model statements for module:  Process 13
;
109$          ASSIGN:        Process 13.NumberIn=Process 13.NumberIn + 1:
                             Process 13.WIP=Process 13.WIP+1;
785$          STACK,         1:Save:NEXT(759$);

759$          QUEUE,         Process 13.Queue;
758$          SEIZE,         2,VA:
                             Resource 7,1:NEXT(757$);

757$          DELAY:         HoursToBaseTime(expo(14/receiptc2# c1,6)),,VA:NEXT(800$);

800$          ASSIGN:        Process 13.WaitTime=Process 13.WaitTime + Diff.WaitTime;
764$          TALLY:         Process 13.WaitTimePerEntity,Diff.WaitTime,1;
766$          TALLY:         Process 13.TotalTimePerEntity,Diff.StartTime,1;
790$          ASSIGN:        Process 13.VATime=Process 13.VATime + Diff.VATime;
791$          TALLY:         Process 13.VATimePerEntity,Diff.VATime,1;
756$          RELEASE:       Resource 7,1;
805$          STACK,         1:Destroy:NEXT(804$);

804$          ASSIGN:        Process 13.NumberOut=Process 13.NumberOut + 1:
                             Process 13.WIP=Process 13.WIP-1:NEXT(67$);


;
;
;     Model statements for module:  Create 6
;

807$          CREATE,        1,MinutesToBaseTime(0.0001),Entity sb1ship# c1:MinutesToBaseTime(1440):NEXT(808$);

808$          ASSIGN:        Create for shipment b shift1 c1.NumberOut=Create for shipment b shift1 c1.NumberOut + 1:NEXT(111$);


;
;
;     Model statements for module:  Decide 104
;
111$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),811$,Yes:
                             Else,812$,Yes;
811$          ASSIGN:        Decide 104.NumberOut True=Decide 104.NumberOut True + 1:NEXT(112$);

812$          ASSIGN:        Decide 104.NumberOut False=Decide 104.NumberOut False + 1:NEXT(113$);


;
;
;     Model statements for module:  Assign 72
;
112$          ASSIGN:        departureb1# c1=disc(0.674,0,0.717,1,0.783,2,0.810,3,0.918,4,0.973,5,1,6,97):NEXT(114$);


;
;
;     Model statements for module:  Decide 105
;
114$          BRANCH,        1:
                             If,departureb1# c1==0,87$,Yes:
                             If,departureb1# c1==1,115$,Yes:
                             Else,116$,Yes;

;
;
;     Model statements for module:  Separate 9
;
116$          DUPLICATE,     100 - 50:
                             departureb1# c1-1,817$,50:NEXT(816$);

816$          ASSIGN:        Separate 9.NumberOut Orig=Separate 9.NumberOut Orig + 1:NEXT(115$);

817$          ASSIGN:        Separate 9.NumberOut Dup=Separate 9.NumberOut Dup + 1:NEXT(115$);


;
;
;     Model statements for module:  Process 14
;
115$          ASSIGN:        Process 14.NumberIn=Process 14.NumberIn + 1:
                             Process 14.WIP=Process 14.WIP+1;
847$          STACK,         1:Save:NEXT(821$);

821$          QUEUE,         Process 14.Queue;
820$          SEIZE,         2,VA:
                             Resource 8,1:NEXT(819$);

819$          DELAY:         HoursToBaseTime(expo(10/departureb1# c1,33)),,VA:NEXT(862$);

862$          ASSIGN:        Process 14.WaitTime=Process 14.WaitTime + Diff.WaitTime;
826$          TALLY:         Process 14.WaitTimePerEntity,Diff.WaitTime,1;
828$          TALLY:         Process 14.TotalTimePerEntity,Diff.StartTime,1;
852$          ASSIGN:        Process 14.VATime=Process 14.VATime + Diff.VATime;
853$          TALLY:         Process 14.VATimePerEntity,Diff.VATime,1;
818$          RELEASE:       Resource 8,1;
867$          STACK,         1:Destroy:NEXT(866$);

866$          ASSIGN:        Process 14.NumberOut=Process 14.NumberOut + 1:
                             Process 14.WIP=Process 14.WIP-1:NEXT(69$);


;
;
;     Model statements for module:  Assign 60
;
69$           ASSIGN:        type=2:NEXT(137$);


;
;
;     Model statements for module:  Decide 115
;
137$          BRANCH,        1:
                             If,type==1,145$,Yes:
                             If,type==2,146$,Yes:
                             Else,147$,Yes;

;
;
;     Model statements for module:  Decide 120
;
147$          BRANCH,        1:
                             If,product3stock>=safety stock,871$,Yes:
                             Else,872$,Yes;
871$          ASSIGN:        Decide 120.NumberOut True=Decide 120.NumberOut True + 1:NEXT(189$);

872$          ASSIGN:        Decide 120.NumberOut False=Decide 120.NumberOut False + 1:NEXT(139$);

189$          COUNT:         dispatchctruck,1:NEXT(22$);


;
;
;     Model statements for module:  Assign 23
;
22$           ASSIGN:        ordersize=8:
                             shipmentqenter=tnow:NEXT(49$);

49$           ASSIGN:        product2stock=(type==2)*(product2stock-8)+(type<>2)*(product2stock-0):
                             product3stock=(type==3)*(product3stock-8)+(type<>3)*(product3stock-0):
                             product1stock=(type==1)*(product1stock-8)+(type<>1)*(product1stock-0);
143$          WRITE,         stock:
                             totalstock,
                             tnow;
149$          QUEUE,         shipmentdockqueue;
141$          SEIZE,         1,Other:
                             dock1,1:NEXT(152$);

152$          TALLY:         time in shipmentq at d1,tnow-shipmentqenter,1:NEXT(48$);


;
;
;     Model statements for module:  Assign 47
;
48$           ASSIGN:        dock_no=1:
                             leave the dock1 queue=tnow:NEXT(24$);

24$           DUPLICATE:     ordersize-1,23$:NEXT(23$);


;
;
;     Model statements for module:  Assign 24
;
23$           ASSIGN:        picked=0:
                             k=1:
                             totalstock=product1stock+product2stock+product3stock:
                             totalexceedingstock=stock1+stock2+stock3:NEXT(25$);

25$           WHILE:         (picked==0):NEXT(26$);


;
;
;     Model statements for module:  Decide 17
;
26$           BRANCH,        1:
                             If,( LocationA(k,1) <> 0  )  &&  ( type == LocationA(k,2) ),873$,Yes:
                             Else,874$,Yes;
873$          ASSIGN:        Decide 17.NumberOut True=Decide 17.NumberOut True + 1:NEXT(27$);

874$          ASSIGN:        Decide 17.NumberOut False=Decide 17.NumberOut False + 1:NEXT(31$);

27$           ASSIGN:        LocationA(k,1)=LocationA(k,1)-1:NEXT(28$);


;
;
;     Model statements for module:  Assign 27
;
28$           ASSIGN:        picked=1:
                             Locationtype=1:NEXT(29$);


;
;
;     Model statements for module:  Decide 18
;
29$           BRANCH,        1:
                             If,LocationA(k,1)==0,875$,Yes:
                             Else,876$,Yes;
875$          ASSIGN:        Decide 18.NumberOut True=Decide 18.NumberOut True + 1:NEXT(30$);

876$          ASSIGN:        Decide 18.NumberOut False=Decide 18.NumberOut False + 1:NEXT(45$);

30$           ASSIGN:        LocationA(k,2)=0:NEXT(45$);


;
;
;     Model statements for module:  Decide 57
;
45$           BRANCH,        1:
                             If,dock_no==1,877$,Yes:
                             Else,878$,Yes;
877$          ASSIGN:        Decide 57.NumberOut True=Decide 57.NumberOut True + 1:NEXT(46$);

878$          ASSIGN:        Decide 57.NumberOut False=Decide 57.NumberOut False + 1:NEXT(47$);


;
;
;     Model statements for module:  Assign 43
;
46$           ASSIGN:        width9=
                             (LocationA(k,1)==4)*0+(LocationA(k,1)==3)*1+(LocationA(k,1)==2)*2+(LocationA(k,1)==1)*3+(LocationA(k,1)==0)*4:
                             distance9=20+k*1+width9:NEXT(36$);

36$           ENDWHILE:NEXT(38$);


;
;
;     Model statements for module:  Seize 9
;
38$           QUEUE,         Seizing a forklift from forklift set at shipment ramp1.Queue;
              SEIZE,         2,Other:
                             SELECT(TransSet3,CYC, trans_no3),1:NEXT(880$);

880$          DELAY:         0.0,,VA:NEXT(486$);


;
;
;     Model statements for module:  Decide 233
;
486$          BRANCH,        1:
                             If,departure from stock exceeded<>1,881$,Yes:
                             Else,882$,Yes;
881$          ASSIGN:        Decide 233.NumberOut True=Decide 233.NumberOut True + 1:NEXT(40$);

882$          ASSIGN:        Decide 233.NumberOut False=Decide 233.NumberOut False + 1:NEXT(487$);


;
;
;     Model statements for module:  Delay 5
;
40$           DELAY:         
                             SecondsToBaseTime((Locationtype==1)*((34.521+(0.915*distance9)+NORM(0,7.3))*2)+(Locationtype==2)*((34.521+(0.915*distance11)+NORM(0,7.3))*2)+(Locationtype==3)*((34.521+(0.915*distance13)+NORM(0,7.3))*2)+(Locationtype==4)*((34.521+(0.915*distance15)+NORM(0,7.3))*2)),,
                             Other:NEXT(72$);

72$           RELEASE:       Member(TransSet3, trans_no3),1;
451$          ASSIGN:        #product from d1=#product from d1+1:NEXT(164$);


;
;
;     Model statements for module:  Decide 123
;
164$          BRANCH,        1:
                             If,#product from d1==8,883$,Yes:
                             Else,884$,Yes;
883$          ASSIGN:        Decide 123.NumberOut True=Decide 123.NumberOut True + 1:NEXT(193$);

884$          ASSIGN:        Decide 123.NumberOut False=Decide 123.NumberOut False + 1:NEXT(453$);

193$          TALLY:         time for pickup to d1,tnow-leave the dock1 queue,1;
452$          ASSIGN:        #product from d1=#product from d1-#product from d1:NEXT(65$);


;
;
;     Model statements for module:  Process 5
;
65$           ASSIGN:        Loading from dock1.NumberIn=Loading from dock1.NumberIn + 1:
                             Loading from dock1.WIP=Loading from dock1.WIP+1;
914$          STACK,         1:Save:NEXT(888$);

888$          QUEUE,         Loading from dock1.Queue;
887$          SEIZE,         1,VA:
                             SELECT(TransSet4,SNB, ),1:NEXT(886$);

886$          DELAY:         SecondsToBaseTime(UNIF(62,83,63)),,VA:NEXT(929$);

929$          ASSIGN:        Loading from dock1.WaitTime=Loading from dock1.WaitTime + Diff.WaitTime;
893$          TALLY:         Loading from dock1.WaitTimePerEntity,Diff.WaitTime,1;
895$          TALLY:         Loading from dock1.TotalTimePerEntity,Diff.StartTime,1;
919$          ASSIGN:        Loading from dock1.VATime=Loading from dock1.VATime + Diff.VATime;
920$          TALLY:         Loading from dock1.VATimePerEntity,Diff.VATime,1;
885$          RELEASE:       SELECT(TransSet4,LAST),1;
934$          STACK,         1:Destroy:NEXT(933$);

933$          ASSIGN:        Loading from dock1.NumberOut=Loading from dock1.NumberOut + 1:
                             Loading from dock1.WIP=Loading from dock1.WIP-1:NEXT(185$);

185$          ASSIGN:        #loaded1=#loaded1+1:NEXT(43$);


;
;
;     Model statements for module:  Decide 38
;
43$           BRANCH,        1:
                             If,#loaded1==ordersize,936$,Yes:
                             Else,937$,Yes;
936$          ASSIGN:        Decide 38.NumberOut True=Decide 38.NumberOut True + 1:NEXT(41$);

937$          ASSIGN:        Decide 38.NumberOut False=Decide 38.NumberOut False + 1:NEXT(42$);


;
;
;     Model statements for module:  Release 13
;
41$           RELEASE:       dock1,1:NEXT(186$);

186$          ASSIGN:        #loaded1=#loaded1-#loaded1;
194$          TALLY:         time in system from d1 for shipment,tnow-shipmentqenter,1;
259$          COUNT:         # of trucks that are in system  more than 60 minutes from d1,(tnow-shipmentqenter)>60;
449$          COUNT:         # of trucks that are in system  more than 45 minutes from d1,(tnow-shipmentqenter)>45;
260$          COUNT:         #of trucks that are from d1,1;
450$          TALLY:         time for loading at d1,tnow-starting time of loading at d1,1:NEXT(42$);


;
;
;     Model statements for module:  Dispose 13
;
42$           ASSIGN:        Dispose 13.NumberOut=Dispose 13.NumberOut + 1;
938$          DISPOSE:       Yes;

453$          ASSIGN:        #product being loaded from d1=#product being loaded from d1+1:NEXT(455$);


;
;
;     Model statements for module:  Decide 219
;
455$          BRANCH,        1:
                             If,#product being loaded from d1==1,939$,Yes:
                             Else,940$,Yes;
939$          ASSIGN:        Decide 219.NumberOut True=Decide 219.NumberOut True + 1:NEXT(454$);

940$          ASSIGN:        Decide 219.NumberOut False=Decide 219.NumberOut False + 1:NEXT(456$);


;
;
;     Model statements for module:  Assign 177
;
454$          ASSIGN:        starting time of loading at d1=tnow:NEXT(65$);


;
;
;     Model statements for module:  Decide 220
;
456$          BRANCH,        1:
                             If,#product being loaded from d1==7,941$,Yes:
                             Else,942$,Yes;
941$          ASSIGN:        Decide 220.NumberOut True=Decide 220.NumberOut True + 1:NEXT(457$);

942$          ASSIGN:        Decide 220.NumberOut False=Decide 220.NumberOut False + 1:NEXT(65$);

457$          ASSIGN:        #product being loaded from d1=#product being loaded from d1-#product being loaded from d1:NEXT(65$);


;
;
;     Model statements for module:  Delay 17
;
487$          DELAY:         SecondsToBaseTime(((34.521+(0.915*averagedistance)+Norm(0,7.3))*2)),,Other:NEXT(72$);


;
;
;     Model statements for module:  Assign 44
;
47$           ASSIGN:        width10=
                             (LocationA(k,1)==4)*0+(LocationA(k,1)==3)*1+(LocationA(k,1)==2)*2+(LocationA(k,1)==1)*3+(LocationA(k,1)==0)*4:
                             distance10=23+k*1+width10:NEXT(36$);


;
;
;     Model statements for module:  Decide 19
;
31$           BRANCH,        1:
                             If,( LocationB(k,1) <> 0 )  &&  ( type == LocationB(k,2) ),943$,Yes:
                             Else,944$,Yes;
943$          ASSIGN:        Decide 19.NumberOut True=Decide 19.NumberOut True + 1:NEXT(32$);

944$          ASSIGN:        Decide 19.NumberOut False=Decide 19.NumberOut False + 1:NEXT(57$);

32$           ASSIGN:        LocationB(k,1)=LocationB(k,1)-1:NEXT(33$);


;
;
;     Model statements for module:  Assign 30
;
33$           ASSIGN:        picked=1:
                             Locationtype=2:NEXT(34$);


;
;
;     Model statements for module:  Decide 21
;
34$           BRANCH,        1:
                             If,LocationB(k,1)==0,945$,Yes:
                             Else,946$,Yes;
945$          ASSIGN:        Decide 21.NumberOut True=Decide 21.NumberOut True + 1:NEXT(35$);

946$          ASSIGN:        Decide 21.NumberOut False=Decide 21.NumberOut False + 1:NEXT(466$);

35$           ASSIGN:        LocationB(k,2)=0:NEXT(466$);


;
;
;     Model statements for module:  Decide 225
;
466$          BRANCH,        1:
                             If,dock_no==1,947$,Yes:
                             Else,948$,Yes;
947$          ASSIGN:        Decide 225.NumberOut True=Decide 225.NumberOut True + 1:NEXT(467$);

948$          ASSIGN:        Decide 225.NumberOut False=Decide 225.NumberOut False + 1:NEXT(468$);


;
;
;     Model statements for module:  Assign 191
;
467$          ASSIGN:        width11=
                             (LocationB(k,1)==4)*0+(LocationB(k,1)==3)*1+(LocationB(k,1)==2)*2+(LocationB(k,1)==1)*3+(LocationB(k,1)==0)*4:
                             distance11=20+k*1+width11:NEXT(36$);


;
;
;     Model statements for module:  Assign 192
;
468$          ASSIGN:        width12=
                             (LocationB(k,1)==4)*0+(LocationB(k,1)==3)*1+(LocationB(k,1)==2)*2+(LocationB(k,1)==1)*3+(LocationB(k,1)==0)*4:
                             distance12=23+k*1+width12:NEXT(36$);


;
;
;     Model statements for module:  Decide 82
;
57$           BRANCH,        1:
                             If,( LocationC(k,1) <> 0 )  &&  ( type == LocationC(k,2) ),949$,Yes:
                             Else,950$,Yes;
949$          ASSIGN:        Decide 82.NumberOut True=Decide 82.NumberOut True + 1:NEXT(58$);

950$          ASSIGN:        Decide 82.NumberOut False=Decide 82.NumberOut False + 1:NEXT(132$);

58$           ASSIGN:        LocationC(k,1)=LocationC(k,1)-1:NEXT(59$);


;
;
;     Model statements for module:  Assign 53
;
59$           ASSIGN:        picked=1:
                             Locationtype=3:NEXT(60$);


;
;
;     Model statements for module:  Decide 83
;
60$           BRANCH,        1:
                             If,LocationC(k,1)==0,951$,Yes:
                             Else,952$,Yes;
951$          ASSIGN:        Decide 83.NumberOut True=Decide 83.NumberOut True + 1:NEXT(61$);

952$          ASSIGN:        Decide 83.NumberOut False=Decide 83.NumberOut False + 1:NEXT(62$);

61$           ASSIGN:        LocationC(k,2)=0:NEXT(62$);


;
;
;     Model statements for module:  Decide 84
;
62$           BRANCH,        1:
                             If,dock_no==1,953$,Yes:
                             Else,954$,Yes;
953$          ASSIGN:        Decide 84.NumberOut True=Decide 84.NumberOut True + 1:NEXT(63$);

954$          ASSIGN:        Decide 84.NumberOut False=Decide 84.NumberOut False + 1:NEXT(64$);


;
;
;     Model statements for module:  Assign 55
;
63$           ASSIGN:        width13=
                             (LocationC(k,1)==7)*0+(LocationC(k,1)==6)*1+(LocationC(k,1)==5)*2+(LocationC(k,1)==4)*3+(LocationC(k,1)==3)*4+(LocationC(k,1)==2)*5+(LocationC(k,1)==1)*6+(LocationC(k,1)==0)*7:
                             distance13=13+k*1+width13:NEXT(36$);


;
;
;     Model statements for module:  Assign 56
;
64$           ASSIGN:        width14=
                             (LocationC(k,1)==7)*0+(LocationC(k,1)==6)*1+(LocationC(k,1)==5)*2+(LocationC(k,1)==4)*3+(LocationC(k,1)==3)*4+(LocationC(k,1)==2)*5+(LocationC(k,1)==1)*6+(LocationC(k,1)==0)*7:
                             distance14=14+k*1+width14:NEXT(36$);


;
;
;     Model statements for module:  Decide 111
;
132$          BRANCH,        1:
                             If,( LocationD(k,1) <> 0 )  &&  ( type == LocationD(k,2) ),955$,Yes:
                             Else,956$,Yes;
955$          ASSIGN:        Decide 111.NumberOut True=Decide 111.NumberOut True + 1:NEXT(133$);

956$          ASSIGN:        Decide 111.NumberOut False=Decide 111.NumberOut False + 1:NEXT(37$);

133$          ASSIGN:        LocationD(k,1)=LocationD(k,1)-1:NEXT(134$);


;
;
;     Model statements for module:  Assign 77
;
134$          ASSIGN:        picked=1:
                             Locationtype=4:NEXT(135$);


;
;
;     Model statements for module:  Decide 112
;
135$          BRANCH,        1:
                             If,LocationD(k,1)==0,957$,Yes:
                             Else,958$,Yes;
957$          ASSIGN:        Decide 112.NumberOut True=Decide 112.NumberOut True + 1:NEXT(136$);

958$          ASSIGN:        Decide 112.NumberOut False=Decide 112.NumberOut False + 1:NEXT(469$);

136$          ASSIGN:        LocationD(k,2)=0:NEXT(469$);


;
;
;     Model statements for module:  Decide 226
;
469$          BRANCH,        1:
                             If,dock_no==1,959$,Yes:
                             Else,960$,Yes;
959$          ASSIGN:        Decide 226.NumberOut True=Decide 226.NumberOut True + 1:NEXT(470$);

960$          ASSIGN:        Decide 226.NumberOut False=Decide 226.NumberOut False + 1:NEXT(471$);


;
;
;     Model statements for module:  Assign 193
;
470$          ASSIGN:        width15=
                             (LocationD(k,1)==7)*0+(LocationD(k,1)==6)*1+(LocationD(k,1)==5)*2+(LocationD(k,1)==4)*3+(LocationD(k,1)==3)*4+(LocationD(k,1)==2)*5+(LocationD(k,1)==1)*6+(LocationD(k,1)==0)*7:
                             distance15=13+k*1+width15:NEXT(36$);


;
;
;     Model statements for module:  Assign 194
;
471$          ASSIGN:        width16=
                             (LocationC(k,1)==7)*0+(LocationC(k,1)==6)*1+(LocationC(k,1)==5)*2+(LocationC(k,1)==4)*3+(LocationC(k,1)==3)*4+(LocationC(k,1)==2)*5+(LocationC(k,1)==1)*6+(LocationC(k,1)==0)*7:
                             distance16=14+k*1+width16:NEXT(36$);


;
;
;     Model statements for module:  Assign 32
;
37$           ASSIGN:        k=k+1:NEXT(480$);


;
;
;     Model statements for module:  Decide 231
;
480$          BRANCH,        1:
                             If,k<=231,961$,Yes:
                             Else,962$,Yes;
961$          ASSIGN:        Decide 231.NumberOut True=Decide 231.NumberOut True + 1:NEXT(36$);

962$          ASSIGN:        Decide 231.NumberOut False=Decide 231.NumberOut False + 1:NEXT(485$);


;
;
;     Model statements for module:  Assign 197
;
485$          ASSIGN:        departure from stock exceeded=1:NEXT(481$);


;
;
;     Model statements for module:  Decide 232
;
481$          BRANCH,        1:
                             If,type==1,482$,Yes:
                             If,type==2,483$,Yes:
                             Else,484$,Yes;
484$          ASSIGN:        stock3=stock3-1:NEXT(38$);

482$          ASSIGN:        stock1=stock1-1:NEXT(38$);

483$          ASSIGN:        stock2=stock2-1:NEXT(38$);


;
;
;     Model statements for module:  Record 32
;
139$          COUNT:         #runaway,1:NEXT(138$);


;
;
;     Model statements for module:  Dispose 21
;
138$          ASSIGN:        Dispose 21.NumberOut=Dispose 21.NumberOut + 1;
965$          DISPOSE:       Yes;


;
;
;     Model statements for module:  Decide 118
;
145$          BRANCH,        1:
                             If,product1stock>=safety stock,966$,Yes:
                             Else,967$,Yes;
966$          ASSIGN:        Decide 118.NumberOut True=Decide 118.NumberOut True + 1:NEXT(187$);

967$          ASSIGN:        Decide 118.NumberOut False=Decide 118.NumberOut False + 1:NEXT(139$);

187$          COUNT:         dispatchatruck,1:NEXT(22$);


;
;
;     Model statements for module:  Decide 119
;
146$          BRANCH,        1:
                             If,product2stock>=safety stock,968$,Yes:
                             Else,969$,Yes;
968$          ASSIGN:        Decide 119.NumberOut True=Decide 119.NumberOut True + 1:NEXT(188$);

969$          ASSIGN:        Decide 119.NumberOut False=Decide 119.NumberOut False + 1:NEXT(139$);

188$          COUNT:         dispatchbtruck,1:NEXT(22$);


;
;
;     Model statements for module:  Dispose 20
;
87$           ASSIGN:        Dispose 20.NumberOut=Dispose 20.NumberOut + 1;
970$          DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 73
;
113$          ASSIGN:        departureb2# c1=disc(0.663,0,0.707,1,0.761,2,0.853,3,0.891,4,0.946,5,0.973,6,0.995,7,1,9,98)
                             :NEXT(117$);


;
;
;     Model statements for module:  Decide 106
;
117$          BRANCH,        1:
                             If,departureb2# c1==0,87$,Yes:
                             If,departureb2# c1==1,118$,Yes:
                             Else,119$,Yes;

;
;
;     Model statements for module:  Separate 10
;
119$          DUPLICATE,     100 - 50:
                             departureb2# c1-1,975$,50:NEXT(974$);

974$          ASSIGN:        Separate 10.NumberOut Orig=Separate 10.NumberOut Orig + 1:NEXT(118$);

975$          ASSIGN:        Separate 10.NumberOut Dup=Separate 10.NumberOut Dup + 1:NEXT(118$);


;
;
;     Model statements for module:  Process 15
;
118$          ASSIGN:        Process 15.NumberIn=Process 15.NumberIn + 1:
                             Process 15.WIP=Process 15.WIP+1;
1005$         STACK,         1:Save:NEXT(979$);

979$          QUEUE,         Process 15.Queue;
978$          SEIZE,         2,VA:
                             Resource 9,1:NEXT(977$);

977$          DELAY:         HoursToBaseTime(expo(14/departureb2# c1,34)),,VA:NEXT(1020$);

1020$         ASSIGN:        Process 15.WaitTime=Process 15.WaitTime + Diff.WaitTime;
984$          TALLY:         Process 15.WaitTimePerEntity,Diff.WaitTime,1;
986$          TALLY:         Process 15.TotalTimePerEntity,Diff.StartTime,1;
1010$         ASSIGN:        Process 15.VATime=Process 15.VATime + Diff.VATime;
1011$         TALLY:         Process 15.VATimePerEntity,Diff.VATime,1;
976$          RELEASE:       Resource 9,1;
1025$         STACK,         1:Destroy:NEXT(1024$);

1024$         ASSIGN:        Process 15.NumberOut=Process 15.NumberOut + 1:
                             Process 15.WIP=Process 15.WIP-1:NEXT(69$);


;
;
;     Model statements for module:  Create 7
;

1027$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sc1ship# c1:MinutesToBaseTime(1440):NEXT(1028$);

1028$         ASSIGN:        Create for shipment c shift1 c1.NumberOut=Create for shipment c shift1 c1.NumberOut + 1:NEXT(120$);


;
;
;     Model statements for module:  Decide 107
;
120$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1031$,Yes:
                             Else,1032$,Yes;
1031$         ASSIGN:        Decide 107.NumberOut True=Decide 107.NumberOut True + 1:NEXT(121$);

1032$         ASSIGN:        Decide 107.NumberOut False=Decide 107.NumberOut False + 1:NEXT(122$);


;
;
;     Model statements for module:  Assign 74
;
121$          ASSIGN:        departurec1# c1=disc(0.842,0,0.891,1,0.924,2,0.935,3,0.962,4,0.978,5,0.995,6,1,7,99):NEXT(123$);


;
;
;     Model statements for module:  Decide 108
;
123$          BRANCH,        1:
                             If,departurec1# c1==0,87$,Yes:
                             If,departurec1# c1==1,124$,Yes:
                             Else,125$,Yes;

;
;
;     Model statements for module:  Separate 11
;
125$          DUPLICATE,     100 - 50:
                             departurec1# c1-1,1037$,50:NEXT(1036$);

1036$         ASSIGN:        Separate 11.NumberOut Orig=Separate 11.NumberOut Orig + 1:NEXT(124$);

1037$         ASSIGN:        Separate 11.NumberOut Dup=Separate 11.NumberOut Dup + 1:NEXT(124$);


;
;
;     Model statements for module:  Process 16
;
124$          ASSIGN:        Process 16.NumberIn=Process 16.NumberIn + 1:
                             Process 16.WIP=Process 16.WIP+1;
1067$         STACK,         1:Save:NEXT(1041$);

1041$         QUEUE,         Process 16.Queue;
1040$         SEIZE,         2,VA:
                             Resource 10,1:NEXT(1039$);

1039$         DELAY:         HoursToBaseTime(expo(10/departurec1# c1,35)),,VA:NEXT(1082$);

1082$         ASSIGN:        Process 16.WaitTime=Process 16.WaitTime + Diff.WaitTime;
1046$         TALLY:         Process 16.WaitTimePerEntity,Diff.WaitTime,1;
1048$         TALLY:         Process 16.TotalTimePerEntity,Diff.StartTime,1;
1072$         ASSIGN:        Process 16.VATime=Process 16.VATime + Diff.VATime;
1073$         TALLY:         Process 16.VATimePerEntity,Diff.VATime,1;
1038$         RELEASE:       Resource 10,1;
1087$         STACK,         1:Destroy:NEXT(1086$);

1086$         ASSIGN:        Process 16.NumberOut=Process 16.NumberOut + 1:
                             Process 16.WIP=Process 16.WIP-1:NEXT(70$);


;
;
;     Model statements for module:  Assign 61
;
70$           ASSIGN:        type=3:NEXT(137$);


;
;
;     Model statements for module:  Assign 75
;
122$          ASSIGN:        departurec2# c1=disc(0.723,0,0.804,1,0.870,2,0.908,3,0.940,4,0.989,5,1,6,100):NEXT(126$);


;
;
;     Model statements for module:  Decide 109
;
126$          BRANCH,        1:
                             If,departurec2# c1==0,87$,Yes:
                             If,departurec2# c1==1,127$,Yes:
                             Else,128$,Yes;

;
;
;     Model statements for module:  Separate 12
;
128$          DUPLICATE,     100 - 50:
                             departurec2# c1-1,1093$,50:NEXT(1092$);

1092$         ASSIGN:        Separate 12.NumberOut Orig=Separate 12.NumberOut Orig + 1:NEXT(127$);

1093$         ASSIGN:        Separate 12.NumberOut Dup=Separate 12.NumberOut Dup + 1:NEXT(127$);


;
;
;     Model statements for module:  Process 17
;
127$          ASSIGN:        Process 17.NumberIn=Process 17.NumberIn + 1:
                             Process 17.WIP=Process 17.WIP+1;
1123$         STACK,         1:Save:NEXT(1097$);

1097$         QUEUE,         Process 17.Queue;
1096$         SEIZE,         2,VA:
                             Resource 11,1:NEXT(1095$);

1095$         DELAY:         HoursToBaseTime(expo(14/departurec2# c1,36)),,VA:NEXT(1138$);

1138$         ASSIGN:        Process 17.WaitTime=Process 17.WaitTime + Diff.WaitTime;
1102$         TALLY:         Process 17.WaitTimePerEntity,Diff.WaitTime,1;
1104$         TALLY:         Process 17.TotalTimePerEntity,Diff.StartTime,1;
1128$         ASSIGN:        Process 17.VATime=Process 17.VATime + Diff.VATime;
1129$         TALLY:         Process 17.VATimePerEntity,Diff.VATime,1;
1094$         RELEASE:       Resource 11,1;
1143$         STACK,         1:Destroy:NEXT(1142$);

1142$         ASSIGN:        Process 17.NumberOut=Process 17.NumberOut + 1:
                             Process 17.WIP=Process 17.WIP-1:NEXT(70$);


;
;
;     Model statements for module:  Create 9
;

1145$         CREATE,        1,HoursToBaseTime(0.0),Entity 1:HoursToBaseTime(24):NEXT(1146$);

1146$         ASSIGN:        Create 9.NumberOut=Create 9.NumberOut + 1:NEXT(77$);


;
;
;     Model statements for module:  Assign 64
;
77$           ASSIGN:        day=day+1:NEXT(78$);


;
;
;     Model statements for module:  Dispose 17
;
78$           ASSIGN:        Dispose 17.NumberOut=Dispose 17.NumberOut + 1;
1149$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Create 11
;

1150$         CREATE,        1,MinutesToBaseTime(600.0001),Entity ra2rec# c1:MinutesToBaseTime(1440):NEXT(1151$);

1151$         ASSIGN:        Create for receiving a shift2 c1.NumberOut=Create for receiving a shift2 c1.NumberOut + 1:NEXT(79$);


;
;
;     Model statements for module:  Decide 93
;
79$           BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1154$,Yes:
                             Else,1155$,Yes;
1154$         ASSIGN:        Decide 93.NumberOut True=Decide 93.NumberOut True + 1:NEXT(71$);

1155$         ASSIGN:        Decide 93.NumberOut False=Decide 93.NumberOut False + 1:NEXT(80$);


;
;
;     Model statements for module:  Assign 62
;
71$           ASSIGN:        receipta1# c1=
                             disc(0.772,0,0.777,2,0.788,4,0.810,5,0.821,6,0.832,7,0.870,8,0.886,9,0.891,10,0.908,11,0.924,12,0.935,13,0.946,14,0.951,16,0.962,17,0.973,18,0.978,22,0.984,23,0.995,27,1,32,65)
                             :NEXT(73$);


;
;
;     Model statements for module:  Decide 92
;
73$           BRANCH,        1:
                             If,receipta1# c1==0,74$,Yes:
                             If,receipta1# c1==1,75$,Yes:
                             Else,76$,Yes;

;
;
;     Model statements for module:  Separate 1
;
76$           DUPLICATE,     100 - 50:
                             receipta1# c1-1,1160$,50:NEXT(1159$);

1159$         ASSIGN:        Separate 1.NumberOut Orig=Separate 1.NumberOut Orig + 1:NEXT(75$);

1160$         ASSIGN:        Separate 1.NumberOut Dup=Separate 1.NumberOut Dup + 1:NEXT(75$);


;
;
;     Model statements for module:  Process 6
;
75$           ASSIGN:        Process 6.NumberIn=Process 6.NumberIn + 1:
                             Process 6.WIP=Process 6.WIP+1;
1190$         STACK,         1:Save:NEXT(1164$);

1164$         QUEUE,         Process 6.Queue;
1163$         SEIZE,         2,VA:
                             Resource 1,1:NEXT(1162$);

1162$         DELAY:         HoursToBaseTime(expo(10/receipta1# c1,1)),,VA:NEXT(1205$);

1205$         ASSIGN:        Process 6.WaitTime=Process 6.WaitTime + Diff.WaitTime;
1169$         TALLY:         Process 6.WaitTimePerEntity,Diff.WaitTime,1;
1171$         TALLY:         Process 6.TotalTimePerEntity,Diff.StartTime,1;
1195$         ASSIGN:        Process 6.VATime=Process 6.VATime + Diff.VATime;
1196$         TALLY:         Process 6.VATimePerEntity,Diff.VATime,1;
1161$         RELEASE:       Resource 1,1;
1210$         STACK,         1:Destroy:NEXT(1209$);

1209$         ASSIGN:        Process 6.NumberOut=Process 6.NumberOut + 1:
                             Process 6.WIP=Process 6.WIP-1:NEXT(0$);


;
;
;     Model statements for module:  Assign 1
;
0$            ASSIGN:        producttype=1:NEXT(157$);


;
;
;     Model statements for module:  Assign 65
;
80$           ASSIGN:        receipta2# c2=
                             disc(0.810,0,0.821,1,0.832,2,0.848,4,0.853,5,0.864,6,0.880,7,0.886,8,0.891,9,0.902,10,0.913,11,0.918,12,0.924,13,0.929,14,0.940,15,0.946,16,0.962,18,0.973,20,0.978,23,0.984,26,0.989,28,0.995,29,1,36,66)
                             :NEXT(81$);


;
;
;     Model statements for module:  Decide 94
;
81$           BRANCH,        1:
                             If,receipta2# c1==0,74$,Yes:
                             If,receipta2# c1==1,92$,Yes:
                             Else,82$,Yes;

;
;
;     Model statements for module:  Separate 2
;
82$           DUPLICATE,     100 - 50:
                             receipta2# c1-1,1216$,50:NEXT(1215$);

1215$         ASSIGN:        Separate 2.NumberOut Orig=Separate 2.NumberOut Orig + 1:NEXT(92$);

1216$         ASSIGN:        Separate 2.NumberOut Dup=Separate 2.NumberOut Dup + 1:NEXT(92$);


;
;
;     Model statements for module:  Process 8
;
92$           ASSIGN:        Process 8.NumberIn=Process 8.NumberIn + 1:
                             Process 8.WIP=Process 8.WIP+1;
1246$         STACK,         1:Save:NEXT(1220$);

1220$         QUEUE,         Process 8.Queue;
1219$         SEIZE,         2,VA:
                             Resource 2,1:NEXT(1218$);

1218$         DELAY:         HoursToBaseTime(expo(14/receipta2# c1,2)),,VA:NEXT(1261$);

1261$         ASSIGN:        Process 8.WaitTime=Process 8.WaitTime + Diff.WaitTime;
1225$         TALLY:         Process 8.WaitTimePerEntity,Diff.WaitTime,1;
1227$         TALLY:         Process 8.TotalTimePerEntity,Diff.StartTime,1;
1251$         ASSIGN:        Process 8.VATime=Process 8.VATime + Diff.VATime;
1252$         TALLY:         Process 8.VATimePerEntity,Diff.VATime,1;
1217$         RELEASE:       Resource 2,1;
1266$         STACK,         1:Destroy:NEXT(1265$);

1265$         ASSIGN:        Process 8.NumberOut=Process 8.NumberOut + 1:
                             Process 8.WIP=Process 8.WIP-1:NEXT(0$);


;
;
;     Model statements for module:  Create 15
;

1268$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sa2ship# c1:MinutesToBaseTime(1440):NEXT(1269$);

1269$         ASSIGN:        Create for shipmenta shift2 c1.NumberOut=Create for shipmenta shift2 c1.NumberOut + 1:NEXT(84$);


;
;
;     Model statements for module:  Decide 95
;
84$           BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1272$,Yes:
                             Else,1273$,Yes;
1272$         ASSIGN:        Decide 95.NumberOut True=Decide 95.NumberOut True + 1:NEXT(83$);

1273$         ASSIGN:        Decide 95.NumberOut False=Decide 95.NumberOut False + 1:NEXT(85$);


;
;
;     Model statements for module:  Assign 66
;
83$           ASSIGN:        departurea1# c1=disc(0.332,0,0.386,1,0.5,2,0.707,3,0.859,4,0.946,5,0.984,6,0.989,7,0.995,8,1,10,95)
                             :NEXT(86$);


;
;
;     Model statements for module:  Decide 96
;
86$           BRANCH,        1:
                             If,departurea1# c1==0,87$,Yes:
                             If,departurea1# c1==1,88$,Yes:
                             Else,89$,Yes;

;
;
;     Model statements for module:  Separate 3
;
89$           DUPLICATE,     100 - 50:
                             departurea1# c1-1,1278$,50:NEXT(1277$);

1277$         ASSIGN:        Separate 3.NumberOut Orig=Separate 3.NumberOut Orig + 1:NEXT(88$);

1278$         ASSIGN:        Separate 3.NumberOut Dup=Separate 3.NumberOut Dup + 1:NEXT(88$);


;
;
;     Model statements for module:  Process 7
;
88$           ASSIGN:        Process 7.NumberIn=Process 7.NumberIn + 1:
                             Process 7.WIP=Process 7.WIP+1;
1308$         STACK,         1:Save:NEXT(1282$);

1282$         QUEUE,         Process 7.Queue;
1281$         SEIZE,         2,VA:
                             Resource 3,1:NEXT(1280$);

1280$         DELAY:         HoursToBaseTime(expo(10/departurea1# c1,31)),,VA:NEXT(1323$);

1323$         ASSIGN:        Process 7.WaitTime=Process 7.WaitTime + Diff.WaitTime;
1287$         TALLY:         Process 7.WaitTimePerEntity,Diff.WaitTime,1;
1289$         TALLY:         Process 7.TotalTimePerEntity,Diff.StartTime,1;
1313$         ASSIGN:        Process 7.VATime=Process 7.VATime + Diff.VATime;
1314$         TALLY:         Process 7.VATimePerEntity,Diff.VATime,1;
1279$         RELEASE:       Resource 3,1;
1328$         STACK,         1:Destroy:NEXT(1327$);

1327$         ASSIGN:        Process 7.NumberOut=Process 7.NumberOut + 1:
                             Process 7.WIP=Process 7.WIP-1:NEXT(68$);


;
;
;     Model statements for module:  Assign 59
;
68$           ASSIGN:        type=1:NEXT(137$);


;
;
;     Model statements for module:  Assign 67
;
85$           ASSIGN:        departurea2# c1=disc(0.315,0,0.408,1,0.505,2,0.685,3,0.837,4,0.929,5,0.989,6,1,7,96):NEXT(90$);


;
;
;     Model statements for module:  Decide 97
;
90$           BRANCH,        1:
                             If,departurea2# c1==0,87$,Yes:
                             If,departurea2# c1==1,93$,Yes:
                             Else,91$,Yes;

;
;
;     Model statements for module:  Separate 4
;
91$           DUPLICATE,     100 - 50:
                             departurea2# c1-1,1334$,50:NEXT(1333$);

1333$         ASSIGN:        Separate 4.NumberOut Orig=Separate 4.NumberOut Orig + 1:NEXT(93$);

1334$         ASSIGN:        Separate 4.NumberOut Dup=Separate 4.NumberOut Dup + 1:NEXT(93$);


;
;
;     Model statements for module:  Process 9
;
93$           ASSIGN:        Process 9.NumberIn=Process 9.NumberIn + 1:
                             Process 9.WIP=Process 9.WIP+1;
1364$         STACK,         1:Save:NEXT(1338$);

1338$         QUEUE,         Process 9.Queue;
1337$         SEIZE,         2,VA:
                             Resource 4,1:NEXT(1336$);

1336$         DELAY:         HoursToBaseTime(expo(14/departurea2# c1,32)),,VA:NEXT(1379$);

1379$         ASSIGN:        Process 9.WaitTime=Process 9.WaitTime + Diff.WaitTime;
1343$         TALLY:         Process 9.WaitTimePerEntity,Diff.WaitTime,1;
1345$         TALLY:         Process 9.TotalTimePerEntity,Diff.StartTime,1;
1369$         ASSIGN:        Process 9.VATime=Process 9.VATime + Diff.VATime;
1370$         TALLY:         Process 9.VATimePerEntity,Diff.VATime,1;
1335$         RELEASE:       Resource 4,1;
1384$         STACK,         1:Destroy:NEXT(1383$);

1383$         ASSIGN:        Process 9.NumberOut=Process 9.NumberOut + 1:
                             Process 9.WIP=Process 9.WIP-1:NEXT(68$);


;
;
;     Model statements for module:  Create 16
;

1386$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rb2rec# c1:MinutesToBaseTime(1440):NEXT(1387$);

1387$         ASSIGN:        Create for receiving b shift2 c1.NumberOut=Create for receiving b shift2 c1.NumberOut + 1:NEXT(94$);


;
;
;     Model statements for module:  Create 17
;

1390$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rc2rec# c1:MinutesToBaseTime(1440):NEXT(1391$);

1391$         ASSIGN:        Create for receiving c shift2 c1.NumberOut=Create for receiving c shift2 c1.NumberOut + 1
                             :NEXT(102$);


;
;
;     Model statements for module:  Create 19
;

1394$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sb2ship# c1:MinutesToBaseTime(1440):NEXT(1395$);

1395$         ASSIGN:        Create for shipment b shift2 c1.NumberOut=Create for shipment b shift2 c1.NumberOut + 1:NEXT(111$);


153$          CREATE,        1,TFIN:,1:NEXT(154$);

154$          WRITE,         rqueueoutput:
                             
                             tavg(time in receiptq at d1),davg(statistic 1),davg(statistic 2),davg(statistic 3),dmax(statistic 1), dmax(statistic 2),dmax(statistic 3),davg(statistic 4),davg(statistic 5),davg(statistic 6),dmax(statistic 4),dmax(statistic 5),dmax(statistic 6),davg(statistic 7),dmax(statistic 7),davg(statistic 8),dmax(statistic 8);
155$          DISPOSE:       No;


161$          CREATE,        1,TFIN:,1:NEXT(162$);

162$          WRITE,         rtimeinsystem:
                             tavg(time in system from d1), tavg(time for putaway from d1);
163$          DISPOSE:       No;


165$          CREATE,        1,TFIN::NEXT(166$);

166$          WRITE,         utilizationf1:
                             FSTAND(forklift1,1),FSTAND(forklift1,2),FSTAND(forklift1,4);
167$          DISPOSE:       No;


168$          CREATE,        1,TFIN::NEXT(169$);

169$          WRITE,         utilizationf2:
                             FSTAND(forklift2,1),FSTAND(forklift2,2),FSTAND(forklift2,4);
170$          DISPOSE:       No;


171$          CREATE,        1,TFIN::NEXT(172$);

172$          WRITE,         utilizationf3:
                             FSTAND(forklift3,1),FSTAND(forklift3,2),FSTAND(forklift3,4);
173$          DISPOSE:       No;


174$          CREATE,        1,TFIN::NEXT(175$);

175$          WRITE,         utilizationf5:
                             FSTAND(forklift5,1),FSTAND(forklift5,2),FSTAND(forklift5,4);
176$          DISPOSE:       No;


177$          CREATE,        1,TFIN::NEXT(178$);

178$          WRITE,         utilizationf6:
                             FSTAND(forklift6,1),FSTAND(forklift6,2),FSTAND(forklift6,4);
179$          DISPOSE:       No;


180$          CREATE,        1,TFIN::NEXT(181$);

181$          WRITE,         utilizationd1:
                             FSTAND(dock 1,1),FSTAND(dock 1,2),FSTAND(dock 1,4);
182$          DISPOSE:       No;


190$          CREATE,        1,TFIN:,1:NEXT(191$);

191$          WRITE,         squeueoutput:
                             
                             tavg(time in shipmentq at d1),nc(dispatchatruck),nc(dispatchbtruck),nc(dispatchctruck),nc(#runaway),tavg(time for pickup to d1),tavg(time for loading at d1);
192$          DISPOSE:       No;


195$          CREATE,        1,TFIN:,1:NEXT(196$);

196$          WRITE,         stimeinsystem:
                             
                             tavg(time in system from d1 for shipment),nc(# of trucks that are in system  more than 60 minutes from d1),nc(#of trucks that are from d1),nc(# of trucks that are in system  more than 45 minutes from d1);
197$          DISPOSE:       No;


;
;
;     Model statements for module:  Create 24
;

1398$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rb1rec# c2:MinutesToBaseTime(1440):NEXT(1399$);

1399$         ASSIGN:        Create for receiving b shift1 c2.NumberOut=Create for receiving b shift1 c2.NumberOut + 1
                             :NEXT(211$);


;
;
;     Model statements for module:  Decide 127
;
211$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1402$,Yes:
                             Else,1403$,Yes;
1402$         ASSIGN:        Decide 127.NumberOut True=Decide 127.NumberOut True + 1:NEXT(489$);

1403$         ASSIGN:        Decide 127.NumberOut False=Decide 127.NumberOut False + 1:NEXT(212$);


;
;
;     Model statements for module:  Assign 199
;
489$          ASSIGN:        receiptb1# c2=
                             disc(0.924,0,0.929,1,0.940,2,0.946,6,0.951,8,0.962,9,0.973,15,0.978,16,0.984,17,0.989,18,0.995,19,1,21,73)
                             :NEXT(213$);


;
;
;     Model statements for module:  Decide 128
;
213$          BRANCH,        1:
                             If,receiptb1# c2==0,203$,Yes:
                             If,receiptb1# c2==1,214$,Yes:
                             Else,215$,Yes;

;
;
;     Model statements for module:  Separate 15
;
215$          DUPLICATE,     100 - 50:
                             receiptb1# c2-1,1408$,50:NEXT(1407$);

1407$         ASSIGN:        Separate 15.NumberOut Orig=Separate 15.NumberOut Orig + 1:NEXT(214$);

1408$         ASSIGN:        Separate 15.NumberOut Dup=Separate 15.NumberOut Dup + 1:NEXT(214$);


;
;
;     Model statements for module:  Process 20
;
214$          ASSIGN:        Process 20.NumberIn=Process 20.NumberIn + 1:
                             Process 20.WIP=Process 20.WIP+1;
1438$         STACK,         1:Save:NEXT(1412$);

1412$         QUEUE,         Process 20.Queue;
1411$         SEIZE,         2,VA:
                             Resource 14,1:NEXT(1410$);

1410$         DELAY:         HoursToBaseTime(expo(10/receiptb1# c2,9)),,VA:NEXT(1453$);

1453$         ASSIGN:        Process 20.WaitTime=Process 20.WaitTime + Diff.WaitTime;
1417$         TALLY:         Process 20.WaitTimePerEntity,Diff.WaitTime,1;
1419$         TALLY:         Process 20.TotalTimePerEntity,Diff.StartTime,1;
1443$         ASSIGN:        Process 20.VATime=Process 20.VATime + Diff.VATime;
1444$         TALLY:         Process 20.VATimePerEntity,Diff.VATime,1;
1409$         RELEASE:       Resource 14,1;
1458$         STACK,         1:Destroy:NEXT(1457$);

1457$         ASSIGN:        Process 20.NumberOut=Process 20.NumberOut + 1:
                             Process 20.WIP=Process 20.WIP-1:NEXT(199$);


;
;
;     Model statements for module:  Assign 83
;
199$          ASSIGN:        producttype=2:NEXT(157$);


;
;
;     Model statements for module:  Dispose 22
;
203$          ASSIGN:        Dispose 22.NumberOut=Dispose 22.NumberOut + 1;
1460$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 88
;
212$          ASSIGN:        receiptb2# c2=
                             disc(0.929,0,0.935,1,0.946,7,0.957,8,0.967,12,0.973,15,0.978,17,0.984,19,0.989,21,0.995,27,1,28,74)
                             :NEXT(216$);


;
;
;     Model statements for module:  Decide 129
;
216$          BRANCH,        1:
                             If,receiptb2# c2==0,203$,Yes:
                             If,receiptb2# c2==1,217$,Yes:
                             Else,218$,Yes;

;
;
;     Model statements for module:  Separate 16
;
218$          DUPLICATE,     100 - 50:
                             receiptb2# c2-1,1465$,50:NEXT(1464$);

1464$         ASSIGN:        Separate 16.NumberOut Orig=Separate 16.NumberOut Orig + 1:NEXT(217$);

1465$         ASSIGN:        Separate 16.NumberOut Dup=Separate 16.NumberOut Dup + 1:NEXT(217$);


;
;
;     Model statements for module:  Process 21
;
217$          ASSIGN:        Process 21.NumberIn=Process 21.NumberIn + 1:
                             Process 21.WIP=Process 21.WIP+1;
1495$         STACK,         1:Save:NEXT(1469$);

1469$         QUEUE,         Process 21.Queue;
1468$         SEIZE,         2,VA:
                             Resource 15,1:NEXT(1467$);

1467$         DELAY:         HoursToBaseTime(expo(14/receiptb2# c2,10)),,VA:NEXT(1510$);

1510$         ASSIGN:        Process 21.WaitTime=Process 21.WaitTime + Diff.WaitTime;
1474$         TALLY:         Process 21.WaitTimePerEntity,Diff.WaitTime,1;
1476$         TALLY:         Process 21.TotalTimePerEntity,Diff.StartTime,1;
1500$         ASSIGN:        Process 21.VATime=Process 21.VATime + Diff.VATime;
1501$         TALLY:         Process 21.VATimePerEntity,Diff.VATime,1;
1466$         RELEASE:       Resource 15,1;
1515$         STACK,         1:Destroy:NEXT(1514$);

1514$         ASSIGN:        Process 21.NumberOut=Process 21.NumberOut + 1:
                             Process 21.WIP=Process 21.WIP-1:NEXT(199$);


;
;
;     Model statements for module:  Create 25
;

1517$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rc1rec# c2:MinutesToBaseTime(1440):NEXT(1518$);

1518$         ASSIGN:        Create for receiving c shift1 c2.NumberOut=Create for receiving c shift1 c2.NumberOut + 1
                             :NEXT(219$);


;
;
;     Model statements for module:  Decide 130
;
219$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1521$,Yes:
                             Else,1522$,Yes;
1521$         ASSIGN:        Decide 130.NumberOut True=Decide 130.NumberOut True + 1:NEXT(220$);

1522$         ASSIGN:        Decide 130.NumberOut False=Decide 130.NumberOut False + 1:NEXT(221$);


;
;
;     Model statements for module:  Assign 89
;
220$          ASSIGN:        receiptc1# c2=disc(0.848,0,0.859,1,0.880,2,0.902,3,0.935,4,0.962,5,0.973,6,0.989,7,0.995,8,1,10,75)
                             :NEXT(222$);


;
;
;     Model statements for module:  Decide 131
;
222$          BRANCH,        1:
                             If,receiptc1# c2==0,203$,Yes:
                             If,receiptc1# c2==1,223$,Yes:
                             Else,224$,Yes;

;
;
;     Model statements for module:  Separate 17
;
224$          DUPLICATE,     100 - 50:
                             receiptc1# c2-1,1527$,50:NEXT(1526$);

1526$         ASSIGN:        Separate 17.NumberOut Orig=Separate 17.NumberOut Orig + 1:NEXT(223$);

1527$         ASSIGN:        Separate 17.NumberOut Dup=Separate 17.NumberOut Dup + 1:NEXT(223$);


;
;
;     Model statements for module:  Process 22
;
223$          ASSIGN:        Process 22.NumberIn=Process 22.NumberIn + 1:
                             Process 22.WIP=Process 22.WIP+1;
1557$         STACK,         1:Save:NEXT(1531$);

1531$         QUEUE,         Process 22.Queue;
1530$         SEIZE,         2,VA:
                             Resource 16,1:NEXT(1529$);

1529$         DELAY:         HoursToBaseTime(expo(10/receiptc1# c2,11)),,VA:NEXT(1572$);

1572$         ASSIGN:        Process 22.WaitTime=Process 22.WaitTime + Diff.WaitTime;
1536$         TALLY:         Process 22.WaitTimePerEntity,Diff.WaitTime,1;
1538$         TALLY:         Process 22.TotalTimePerEntity,Diff.StartTime,1;
1562$         ASSIGN:        Process 22.VATime=Process 22.VATime + Diff.VATime;
1563$         TALLY:         Process 22.VATimePerEntity,Diff.VATime,1;
1528$         RELEASE:       Resource 16,1;
1577$         STACK,         1:Destroy:NEXT(1576$);

1576$         ASSIGN:        Process 22.NumberOut=Process 22.NumberOut + 1:
                             Process 22.WIP=Process 22.WIP-1:NEXT(200$);


;
;
;     Model statements for module:  Assign 84
;
200$          ASSIGN:        producttype=3:NEXT(157$);


;
;
;     Model statements for module:  Assign 90
;
221$          ASSIGN:        receiptc2# c2=disc(0.848,0,0.864,1,0.875,2,0.913,3,0.946,4,0.973,5,0.989,6,0.995,8,1,10,76)
                             :NEXT(225$);


;
;
;     Model statements for module:  Decide 132
;
225$          BRANCH,        1:
                             If,receiptc2# c2==0,203$,Yes:
                             If,receiptc2# c2==1,226$,Yes:
                             Else,227$,Yes;

;
;
;     Model statements for module:  Separate 18
;
227$          DUPLICATE,     100 - 50:
                             receiptc2# c2-1,1583$,50:NEXT(1582$);

1582$         ASSIGN:        Separate 18.NumberOut Orig=Separate 18.NumberOut Orig + 1:NEXT(226$);

1583$         ASSIGN:        Separate 18.NumberOut Dup=Separate 18.NumberOut Dup + 1:NEXT(226$);


;
;
;     Model statements for module:  Process 23
;
226$          ASSIGN:        Process 23.NumberIn=Process 23.NumberIn + 1:
                             Process 23.WIP=Process 23.WIP+1;
1613$         STACK,         1:Save:NEXT(1587$);

1587$         QUEUE,         Process 23.Queue;
1586$         SEIZE,         2,VA:
                             Resource 17,1:NEXT(1585$);

1585$         DELAY:         HoursToBaseTime(expo(14/receiptc2# c2,12)),,VA:NEXT(1628$);

1628$         ASSIGN:        Process 23.WaitTime=Process 23.WaitTime + Diff.WaitTime;
1592$         TALLY:         Process 23.WaitTimePerEntity,Diff.WaitTime,1;
1594$         TALLY:         Process 23.TotalTimePerEntity,Diff.StartTime,1;
1618$         ASSIGN:        Process 23.VATime=Process 23.VATime + Diff.VATime;
1619$         TALLY:         Process 23.VATimePerEntity,Diff.VATime,1;
1584$         RELEASE:       Resource 17,1;
1633$         STACK,         1:Destroy:NEXT(1632$);

1632$         ASSIGN:        Process 23.NumberOut=Process 23.NumberOut + 1:
                             Process 23.WIP=Process 23.WIP-1:NEXT(200$);


;
;
;     Model statements for module:  Create 27
;

1635$         CREATE,        1,MinutesToBaseTime(600.0001),Entity ra2rec# c2:MinutesToBaseTime(1440):NEXT(1636$);

1636$         ASSIGN:        Create for receiving a shift2 c2.NumberOut=Create for receiving a shift2 c2.NumberOut + 1
                             :NEXT(206$);


;
;
;     Model statements for module:  Decide 125
;
206$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1639$,Yes:
                             Else,1640$,Yes;
1639$         ASSIGN:        Decide 125.NumberOut True=Decide 125.NumberOut True + 1:NEXT(201$);

1640$         ASSIGN:        Decide 125.NumberOut False=Decide 125.NumberOut False + 1:NEXT(207$);


;
;
;     Model statements for module:  Assign 85
;
201$          ASSIGN:        receipta1# c2=
                             disc(0.772,0,0.777,2,0.788,4,0.810,5,0.821,6,0.832,7,0.870,8,0.886,9,0.891,10,0.908,11,0.924,12,0.935,13,0.946,14,0.951,16,0.962,17,0.973,18,0.978,22,0.984,23,0.995,27,1,32,71)
                             :NEXT(202$);


;
;
;     Model statements for module:  Decide 124
;
202$          BRANCH,        1:
                             If,receipta1# c2==0,203$,Yes:
                             If,receipta1# c2==1,204$,Yes:
                             Else,205$,Yes;

;
;
;     Model statements for module:  Separate 13
;
205$          DUPLICATE,     100 - 50:
                             receipta1# c2-1,1645$,50:NEXT(1644$);

1644$         ASSIGN:        Separate 13.NumberOut Orig=Separate 13.NumberOut Orig + 1:NEXT(204$);

1645$         ASSIGN:        Separate 13.NumberOut Dup=Separate 13.NumberOut Dup + 1:NEXT(204$);


;
;
;     Model statements for module:  Process 18
;
204$          ASSIGN:        Process 18.NumberIn=Process 18.NumberIn + 1:
                             Process 18.WIP=Process 18.WIP+1;
1675$         STACK,         1:Save:NEXT(1649$);

1649$         QUEUE,         Process 18.Queue;
1648$         SEIZE,         2,VA:
                             Resource 12,1:NEXT(1647$);

1647$         DELAY:         HoursToBaseTime(expo(10/receipta1# c2,7)),,VA:NEXT(1690$);

1690$         ASSIGN:        Process 18.WaitTime=Process 18.WaitTime + Diff.WaitTime;
1654$         TALLY:         Process 18.WaitTimePerEntity,Diff.WaitTime,1;
1656$         TALLY:         Process 18.TotalTimePerEntity,Diff.StartTime,1;
1680$         ASSIGN:        Process 18.VATime=Process 18.VATime + Diff.VATime;
1681$         TALLY:         Process 18.VATimePerEntity,Diff.VATime,1;
1646$         RELEASE:       Resource 12,1;
1695$         STACK,         1:Destroy:NEXT(1694$);

1694$         ASSIGN:        Process 18.NumberOut=Process 18.NumberOut + 1:
                             Process 18.WIP=Process 18.WIP-1:NEXT(198$);


;
;
;     Model statements for module:  Assign 82
;
198$          ASSIGN:        producttype=1:NEXT(157$);


;
;
;     Model statements for module:  Assign 86
;
207$          ASSIGN:        receipta2# c2=
                             disc(0.810,0,0.821,1,0.832,2,0.848,4,0.853,5,0.864,6,0.880,7,0.886,8,0.891,9,0.902,10,0.913,11,0.918,12,0.924,13,0.929,14,0.940,15,0.946,16,0.962,18,0.973,20,0.978,23,0.984,26,0.989,28,0.995,29,1,36,72)
                             :NEXT(208$);


;
;
;     Model statements for module:  Decide 126
;
208$          BRANCH,        1:
                             If,receipta2# c2==0,203$,Yes:
                             If,receipta2# c2==1,210$,Yes:
                             Else,209$,Yes;

;
;
;     Model statements for module:  Separate 14
;
209$          DUPLICATE,     100 - 50:
                             receipta2# c2-1,1701$,50:NEXT(1700$);

1700$         ASSIGN:        Separate 14.NumberOut Orig=Separate 14.NumberOut Orig + 1:NEXT(210$);

1701$         ASSIGN:        Separate 14.NumberOut Dup=Separate 14.NumberOut Dup + 1:NEXT(210$);


;
;
;     Model statements for module:  Process 19
;
210$          ASSIGN:        Process 19.NumberIn=Process 19.NumberIn + 1:
                             Process 19.WIP=Process 19.WIP+1;
1731$         STACK,         1:Save:NEXT(1705$);

1705$         QUEUE,         Process 19.Queue;
1704$         SEIZE,         2,VA:
                             Resource 13,1:NEXT(1703$);

1703$         DELAY:         HoursToBaseTime(expo(14/receipta2# c2,8)),,VA:NEXT(1746$);

1746$         ASSIGN:        Process 19.WaitTime=Process 19.WaitTime + Diff.WaitTime;
1710$         TALLY:         Process 19.WaitTimePerEntity,Diff.WaitTime,1;
1712$         TALLY:         Process 19.TotalTimePerEntity,Diff.StartTime,1;
1736$         ASSIGN:        Process 19.VATime=Process 19.VATime + Diff.VATime;
1737$         TALLY:         Process 19.VATimePerEntity,Diff.VATime,1;
1702$         RELEASE:       Resource 13,1;
1751$         STACK,         1:Destroy:NEXT(1750$);

1750$         ASSIGN:        Process 19.NumberOut=Process 19.NumberOut + 1:
                             Process 19.WIP=Process 19.WIP-1:NEXT(198$);


;
;
;     Model statements for module:  Create 28
;

1753$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rb2rec# c2:MinutesToBaseTime(1440):NEXT(1754$);

1754$         ASSIGN:        Create for receiving b shift2 c2.NumberOut=Create for receiving b shift2 c2.NumberOut + 1
                             :NEXT(211$);


;
;
;     Model statements for module:  Create 29
;

1757$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rc2rec# c2:MinutesToBaseTime(1440):NEXT(1758$);

1758$         ASSIGN:        Create for receiving c shift2 c2.NumberOut=Create for receiving c shift2 c2.NumberOut + 1
                             :NEXT(219$);


;
;
;     Model statements for module:  Create 39
;

1761$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sb1ship# c2:MinutesToBaseTime(1440):NEXT(1762$);

1762$         ASSIGN:        Create for shipment b shift1 c2.NumberOut=Create for shipment b shift1 c2.NumberOut + 1:NEXT(241$);


;
;
;     Model statements for module:  Decide 145
;
241$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1765$,Yes:
                             Else,1766$,Yes;
1765$         ASSIGN:        Decide 145.NumberOut True=Decide 145.NumberOut True + 1:NEXT(242$);

1766$         ASSIGN:        Decide 145.NumberOut False=Decide 145.NumberOut False + 1:NEXT(243$);


;
;
;     Model statements for module:  Assign 105
;
242$          ASSIGN:        departureb1# c2=disc(0.674,0,0.717,1,0.783,2,0.810,3,0.918,4,0.973,5,1,6,103):NEXT(244$);


;
;
;     Model statements for module:  Decide 146
;
244$          BRANCH,        1:
                             If,departureb1# c2==0,235$,Yes:
                             If,departureb1# c2==1,245$,Yes:
                             Else,246$,Yes;

;
;
;     Model statements for module:  Separate 27
;
246$          DUPLICATE,     100 - 50:
                             departureb1# c2-1,1771$,50:NEXT(1770$);

1770$         ASSIGN:        Separate 27.NumberOut Orig=Separate 27.NumberOut Orig + 1:NEXT(245$);

1771$         ASSIGN:        Separate 27.NumberOut Dup=Separate 27.NumberOut Dup + 1:NEXT(245$);


;
;
;     Model statements for module:  Process 32
;
245$          ASSIGN:        Process 32.NumberIn=Process 32.NumberIn + 1:
                             Process 32.WIP=Process 32.WIP+1;
1801$         STACK,         1:Save:NEXT(1775$);

1775$         QUEUE,         Process 32.Queue;
1774$         SEIZE,         2,VA:
                             Resource 20,1:NEXT(1773$);

1773$         DELAY:         HoursToBaseTime(expo(10/departureb1# c2,39)),,VA:NEXT(1816$);

1816$         ASSIGN:        Process 32.WaitTime=Process 32.WaitTime + Diff.WaitTime;
1780$         TALLY:         Process 32.WaitTimePerEntity,Diff.WaitTime,1;
1782$         TALLY:         Process 32.TotalTimePerEntity,Diff.StartTime,1;
1806$         ASSIGN:        Process 32.VATime=Process 32.VATime + Diff.VATime;
1807$         TALLY:         Process 32.VATimePerEntity,Diff.VATime,1;
1772$         RELEASE:       Resource 20,1;
1821$         STACK,         1:Destroy:NEXT(1820$);

1820$         ASSIGN:        Process 32.NumberOut=Process 32.NumberOut + 1:
                             Process 32.WIP=Process 32.WIP-1:NEXT(229$);


;
;
;     Model statements for module:  Assign 101
;
229$          ASSIGN:        type=2:NEXT(137$);


;
;
;     Model statements for module:  Dispose 24
;
235$          ASSIGN:        Dispose 24.NumberOut=Dispose 24.NumberOut + 1;
1823$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 106
;
243$          ASSIGN:        departureb2# c2=disc(0.663,0,0.707,1,0.761,2,0.853,3,0.891,4,0.946,5,0.973,6,0.995,7,1,9,104)
                             :NEXT(247$);


;
;
;     Model statements for module:  Decide 147
;
247$          BRANCH,        1:
                             If,departureb2# c2==0,235$,Yes:
                             If,departureb2# c2==1,248$,Yes:
                             Else,249$,Yes;

;
;
;     Model statements for module:  Separate 28
;
249$          DUPLICATE,     100 - 50:
                             departureb2# c2-1,1828$,50:NEXT(1827$);

1827$         ASSIGN:        Separate 28.NumberOut Orig=Separate 28.NumberOut Orig + 1:NEXT(248$);

1828$         ASSIGN:        Separate 28.NumberOut Dup=Separate 28.NumberOut Dup + 1:NEXT(248$);


;
;
;     Model statements for module:  Process 33
;
248$          ASSIGN:        Process 33.NumberIn=Process 33.NumberIn + 1:
                             Process 33.WIP=Process 33.WIP+1;
1858$         STACK,         1:Save:NEXT(1832$);

1832$         QUEUE,         Process 33.Queue;
1831$         SEIZE,         2,VA:
                             Resource 21,1:NEXT(1830$);

1830$         DELAY:         HoursToBaseTime(expo(14/departureb2# c2,40)),,VA:NEXT(1873$);

1873$         ASSIGN:        Process 33.WaitTime=Process 33.WaitTime + Diff.WaitTime;
1837$         TALLY:         Process 33.WaitTimePerEntity,Diff.WaitTime,1;
1839$         TALLY:         Process 33.TotalTimePerEntity,Diff.StartTime,1;
1863$         ASSIGN:        Process 33.VATime=Process 33.VATime + Diff.VATime;
1864$         TALLY:         Process 33.VATimePerEntity,Diff.VATime,1;
1829$         RELEASE:       Resource 21,1;
1878$         STACK,         1:Destroy:NEXT(1877$);

1877$         ASSIGN:        Process 33.NumberOut=Process 33.NumberOut + 1:
                             Process 33.WIP=Process 33.WIP-1:NEXT(229$);


;
;
;     Model statements for module:  Create 40
;

1880$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sc1ship# c2:MinutesToBaseTime(1440):NEXT(1881$);

1881$         ASSIGN:        Create for shipment c shift1 c2.NumberOut=Create for shipment c shift1 c2.NumberOut + 1:NEXT(250$);


;
;
;     Model statements for module:  Decide 148
;
250$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),1884$,Yes:
                             Else,1885$,Yes;
1884$         ASSIGN:        Decide 148.NumberOut True=Decide 148.NumberOut True + 1:NEXT(251$);

1885$         ASSIGN:        Decide 148.NumberOut False=Decide 148.NumberOut False + 1:NEXT(252$);


;
;
;     Model statements for module:  Assign 107
;
251$          ASSIGN:        departurec1# c2=disc(0.842,0,0.891,1,0.924,2,0.935,3,0.962,4,0.978,5,0.995,6,1,7,105):NEXT(253$);


;
;
;     Model statements for module:  Decide 149
;
253$          BRANCH,        1:
                             If,departurec1# c2==0,235$,Yes:
                             If,departurec1# c2==1,254$,Yes:
                             Else,255$,Yes;

;
;
;     Model statements for module:  Separate 29
;
255$          DUPLICATE,     100 - 50:
                             departurec1# c2-1,1890$,50:NEXT(1889$);

1889$         ASSIGN:        Separate 29.NumberOut Orig=Separate 29.NumberOut Orig + 1:NEXT(254$);

1890$         ASSIGN:        Separate 29.NumberOut Dup=Separate 29.NumberOut Dup + 1:NEXT(254$);


;
;
;     Model statements for module:  Process 34
;
254$          ASSIGN:        Process 34.NumberIn=Process 34.NumberIn + 1:
                             Process 34.WIP=Process 34.WIP+1;
1920$         STACK,         1:Save:NEXT(1894$);

1894$         QUEUE,         Process 34.Queue;
1893$         SEIZE,         2,VA:
                             Resource 22,1:NEXT(1892$);

1892$         DELAY:         HoursToBaseTime(expo(10/departurec1# c2,41)),,VA:NEXT(1935$);

1935$         ASSIGN:        Process 34.WaitTime=Process 34.WaitTime + Diff.WaitTime;
1899$         TALLY:         Process 34.WaitTimePerEntity,Diff.WaitTime,1;
1901$         TALLY:         Process 34.TotalTimePerEntity,Diff.StartTime,1;
1925$         ASSIGN:        Process 34.VATime=Process 34.VATime + Diff.VATime;
1926$         TALLY:         Process 34.VATimePerEntity,Diff.VATime,1;
1891$         RELEASE:       Resource 22,1;
1940$         STACK,         1:Destroy:NEXT(1939$);

1939$         ASSIGN:        Process 34.NumberOut=Process 34.NumberOut + 1:
                             Process 34.WIP=Process 34.WIP-1:NEXT(230$);


;
;
;     Model statements for module:  Assign 102
;
230$          ASSIGN:        type=3:NEXT(137$);


;
;
;     Model statements for module:  Assign 108
;
252$          ASSIGN:        departurec2# c2=disc(0.723,0,0.804,1,0.870,2,0.908,3,0.940,4,0.989,5,1,6,106):NEXT(256$);


;
;
;     Model statements for module:  Decide 150
;
256$          BRANCH,        1:
                             If,departurec2# c2==0,235$,Yes:
                             If,departurec2# c2==1,257$,Yes:
                             Else,258$,Yes;

;
;
;     Model statements for module:  Separate 30
;
258$          DUPLICATE,     100 - 50:
                             departurec2# c2-1,1946$,50:NEXT(1945$);

1945$         ASSIGN:        Separate 30.NumberOut Orig=Separate 30.NumberOut Orig + 1:NEXT(257$);

1946$         ASSIGN:        Separate 30.NumberOut Dup=Separate 30.NumberOut Dup + 1:NEXT(257$);


;
;
;     Model statements for module:  Process 35
;
257$          ASSIGN:        Process 35.NumberIn=Process 35.NumberIn + 1:
                             Process 35.WIP=Process 35.WIP+1;
1976$         STACK,         1:Save:NEXT(1950$);

1950$         QUEUE,         Process 35.Queue;
1949$         SEIZE,         2,VA:
                             Resource 23,1:NEXT(1948$);

1948$         DELAY:         HoursToBaseTime(expo(14/departurec2# c2,42)),,VA:NEXT(1991$);

1991$         ASSIGN:        Process 35.WaitTime=Process 35.WaitTime + Diff.WaitTime;
1955$         TALLY:         Process 35.WaitTimePerEntity,Diff.WaitTime,1;
1957$         TALLY:         Process 35.TotalTimePerEntity,Diff.StartTime,1;
1981$         ASSIGN:        Process 35.VATime=Process 35.VATime + Diff.VATime;
1982$         TALLY:         Process 35.VATimePerEntity,Diff.VATime,1;
1947$         RELEASE:       Resource 23,1;
1996$         STACK,         1:Destroy:NEXT(1995$);

1995$         ASSIGN:        Process 35.NumberOut=Process 35.NumberOut + 1:
                             Process 35.WIP=Process 35.WIP-1:NEXT(230$);


;
;
;     Model statements for module:  Create 42
;

1998$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sa2ship# c2:MinutesToBaseTime(1440):NEXT(1999$);

1999$         ASSIGN:        Create for shipmenta shift2 c2.NumberOut=Create for shipmenta shift2 c2.NumberOut + 1:NEXT(232$);


;
;
;     Model statements for module:  Decide 142
;
232$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2002$,Yes:
                             Else,2003$,Yes;
2002$         ASSIGN:        Decide 142.NumberOut True=Decide 142.NumberOut True + 1:NEXT(231$);

2003$         ASSIGN:        Decide 142.NumberOut False=Decide 142.NumberOut False + 1:NEXT(233$);


;
;
;     Model statements for module:  Assign 103
;
231$          ASSIGN:        departurea1# c2=
                             disc(0.332,0,0.386,1,0.5,2,0.707,3,0.859,4,0.946,5,0.984,6,0.989,7,0.995,8,1,10,101):NEXT(234$);


;
;
;     Model statements for module:  Decide 143
;
234$          BRANCH,        1:
                             If,departurea1# c2==0,235$,Yes:
                             If,departurea1# c2==1,236$,Yes:
                             Else,237$,Yes;

;
;
;     Model statements for module:  Separate 25
;
237$          DUPLICATE,     100 - 50:
                             departurea1# c2-1,2008$,50:NEXT(2007$);

2007$         ASSIGN:        Separate 25.NumberOut Orig=Separate 25.NumberOut Orig + 1:NEXT(236$);

2008$         ASSIGN:        Separate 25.NumberOut Dup=Separate 25.NumberOut Dup + 1:NEXT(236$);


;
;
;     Model statements for module:  Process 30
;
236$          ASSIGN:        Process 30.NumberIn=Process 30.NumberIn + 1:
                             Process 30.WIP=Process 30.WIP+1;
2038$         STACK,         1:Save:NEXT(2012$);

2012$         QUEUE,         Process 30.Queue;
2011$         SEIZE,         2,VA:
                             Resource 18,1:NEXT(2010$);

2010$         DELAY:         HoursToBaseTime(expo(10/departurea1# c2,37)),,VA:NEXT(2053$);

2053$         ASSIGN:        Process 30.WaitTime=Process 30.WaitTime + Diff.WaitTime;
2017$         TALLY:         Process 30.WaitTimePerEntity,Diff.WaitTime,1;
2019$         TALLY:         Process 30.TotalTimePerEntity,Diff.StartTime,1;
2043$         ASSIGN:        Process 30.VATime=Process 30.VATime + Diff.VATime;
2044$         TALLY:         Process 30.VATimePerEntity,Diff.VATime,1;
2009$         RELEASE:       Resource 18,1;
2058$         STACK,         1:Destroy:NEXT(2057$);

2057$         ASSIGN:        Process 30.NumberOut=Process 30.NumberOut + 1:
                             Process 30.WIP=Process 30.WIP-1:NEXT(228$);


;
;
;     Model statements for module:  Assign 100
;
228$          ASSIGN:        type=1:NEXT(137$);


;
;
;     Model statements for module:  Assign 104
;
233$          ASSIGN:        departurea2# c2=disc(0.315,0,0.408,1,0.505,2,0.685,3,0.837,4,0.929,5,0.989,6,1,7,102):NEXT(238$);


;
;
;     Model statements for module:  Decide 144
;
238$          BRANCH,        1:
                             If,departurea2# c2==0,235$,Yes:
                             If,departurea2# c2==1,240$,Yes:
                             Else,239$,Yes;

;
;
;     Model statements for module:  Separate 26
;
239$          DUPLICATE,     100 - 50:
                             departurea2# c2-1,2064$,50:NEXT(2063$);

2063$         ASSIGN:        Separate 26.NumberOut Orig=Separate 26.NumberOut Orig + 1:NEXT(240$);

2064$         ASSIGN:        Separate 26.NumberOut Dup=Separate 26.NumberOut Dup + 1:NEXT(240$);


;
;
;     Model statements for module:  Process 31
;
240$          ASSIGN:        Process 31.NumberIn=Process 31.NumberIn + 1:
                             Process 31.WIP=Process 31.WIP+1;
2094$         STACK,         1:Save:NEXT(2068$);

2068$         QUEUE,         Process 31.Queue;
2067$         SEIZE,         2,VA:
                             Resource 19,1:NEXT(2066$);

2066$         DELAY:         HoursToBaseTime(expo(14/departurea2# c2,38)),,VA:NEXT(2109$);

2109$         ASSIGN:        Process 31.WaitTime=Process 31.WaitTime + Diff.WaitTime;
2073$         TALLY:         Process 31.WaitTimePerEntity,Diff.WaitTime,1;
2075$         TALLY:         Process 31.TotalTimePerEntity,Diff.StartTime,1;
2099$         ASSIGN:        Process 31.VATime=Process 31.VATime + Diff.VATime;
2100$         TALLY:         Process 31.VATimePerEntity,Diff.VATime,1;
2065$         RELEASE:       Resource 19,1;
2114$         STACK,         1:Destroy:NEXT(2113$);

2113$         ASSIGN:        Process 31.NumberOut=Process 31.NumberOut + 1:
                             Process 31.WIP=Process 31.WIP-1:NEXT(228$);


;
;
;     Model statements for module:  Create 43
;

2116$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sb2ship# c2:MinutesToBaseTime(1440):NEXT(2117$);

2117$         ASSIGN:        Create for shipment b shift2 c2.NumberOut=Create for shipment b shift2 c2.NumberOut + 1:NEXT(241$);


;
;
;     Model statements for module:  Create 45
;

2120$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rb1rec# c3:MinutesToBaseTime(1440):NEXT(2121$);

2121$         ASSIGN:        Create for receiving b shift1 c3.NumberOut=Create for receiving b shift1 c3.NumberOut + 1
                             :NEXT(276$);


;
;
;     Model statements for module:  Decide 157
;
276$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2124$,Yes:
                             Else,2125$,Yes;
2124$         ASSIGN:        Decide 157.NumberOut True=Decide 157.NumberOut True + 1:NEXT(277$);

2125$         ASSIGN:        Decide 157.NumberOut False=Decide 157.NumberOut False + 1:NEXT(278$);


;
;
;     Model statements for module:  Assign 117
;
277$          ASSIGN:        receiptb1# c3=
                             disc(0.924,0,0.929,1,0.940,2,0.946,6,0.951,8,0.962,9,0.973,15,0.978,16,0.984,17,0.989,18,0.995,19,1,21,79)
                             :NEXT(279$);


;
;
;     Model statements for module:  Decide 158
;
279$          BRANCH,        1:
                             If,receiptb1# c3==0,268$,Yes:
                             If,receiptb1# c3==1,280$,Yes:
                             Else,281$,Yes;

;
;
;     Model statements for module:  Separate 33
;
281$          DUPLICATE,     100 - 50:
                             receiptb1# c3-1,2130$,50:NEXT(2129$);

2129$         ASSIGN:        Separate 33.NumberOut Orig=Separate 33.NumberOut Orig + 1:NEXT(280$);

2130$         ASSIGN:        Separate 33.NumberOut Dup=Separate 33.NumberOut Dup + 1:NEXT(280$);


;
;
;     Model statements for module:  Process 38
;
280$          ASSIGN:        Process 38.NumberIn=Process 38.NumberIn + 1:
                             Process 38.WIP=Process 38.WIP+1;
2160$         STACK,         1:Save:NEXT(2134$);

2134$         QUEUE,         Process 38.Queue;
2133$         SEIZE,         2,VA:
                             Resource 26,1:NEXT(2132$);

2132$         DELAY:         HoursToBaseTime(expo(10/receiptb1# c3,15)),,VA:NEXT(2175$);

2175$         ASSIGN:        Process 38.WaitTime=Process 38.WaitTime + Diff.WaitTime;
2139$         TALLY:         Process 38.WaitTimePerEntity,Diff.WaitTime,1;
2141$         TALLY:         Process 38.TotalTimePerEntity,Diff.StartTime,1;
2165$         ASSIGN:        Process 38.VATime=Process 38.VATime + Diff.VATime;
2166$         TALLY:         Process 38.VATimePerEntity,Diff.VATime,1;
2131$         RELEASE:       Resource 26,1;
2180$         STACK,         1:Destroy:NEXT(2179$);

2179$         ASSIGN:        Process 38.NumberOut=Process 38.NumberOut + 1:
                             Process 38.WIP=Process 38.WIP-1:NEXT(264$);


;
;
;     Model statements for module:  Assign 113
;
264$          ASSIGN:        producttype=2:NEXT(157$);


;
;
;     Model statements for module:  Dispose 25
;
268$          ASSIGN:        Dispose 25.NumberOut=Dispose 25.NumberOut + 1;
2182$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 118
;
278$          ASSIGN:        receiptb2# c3=
                             disc(0.929,0,0.935,1,0.946,7,0.957,8,0.967,12,0.973,15,0.978,17,0.984,19,0.989,21,0.995,27,1,28,80)
                             :NEXT(282$);


;
;
;     Model statements for module:  Decide 159
;
282$          BRANCH,        1:
                             If,receiptb2# c3==0,268$,Yes:
                             If,receiptb2# c3==1,283$,Yes:
                             Else,284$,Yes;

;
;
;     Model statements for module:  Separate 34
;
284$          DUPLICATE,     100 - 50:
                             receiptb2# c3-1,2187$,50:NEXT(2186$);

2186$         ASSIGN:        Separate 34.NumberOut Orig=Separate 34.NumberOut Orig + 1:NEXT(283$);

2187$         ASSIGN:        Separate 34.NumberOut Dup=Separate 34.NumberOut Dup + 1:NEXT(283$);


;
;
;     Model statements for module:  Process 39
;
283$          ASSIGN:        Process 39.NumberIn=Process 39.NumberIn + 1:
                             Process 39.WIP=Process 39.WIP+1;
2217$         STACK,         1:Save:NEXT(2191$);

2191$         QUEUE,         Process 39.Queue;
2190$         SEIZE,         2,VA:
                             Resource 27,1:NEXT(2189$);

2189$         DELAY:         HoursToBaseTime(expo(14/receiptb2# c3,16)),,VA:NEXT(2232$);

2232$         ASSIGN:        Process 39.WaitTime=Process 39.WaitTime + Diff.WaitTime;
2196$         TALLY:         Process 39.WaitTimePerEntity,Diff.WaitTime,1;
2198$         TALLY:         Process 39.TotalTimePerEntity,Diff.StartTime,1;
2222$         ASSIGN:        Process 39.VATime=Process 39.VATime + Diff.VATime;
2223$         TALLY:         Process 39.VATimePerEntity,Diff.VATime,1;
2188$         RELEASE:       Resource 27,1;
2237$         STACK,         1:Destroy:NEXT(2236$);

2236$         ASSIGN:        Process 39.NumberOut=Process 39.NumberOut + 1:
                             Process 39.WIP=Process 39.WIP-1:NEXT(264$);


;
;
;     Model statements for module:  Create 46
;

2239$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rc1rec# c3:MinutesToBaseTime(1440):NEXT(2240$);

2240$         ASSIGN:        Create for receiving c shift1 c3.NumberOut=Create for receiving c shift1 c3.NumberOut + 1
                             :NEXT(285$);


;
;
;     Model statements for module:  Decide 160
;
285$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2243$,Yes:
                             Else,2244$,Yes;
2243$         ASSIGN:        Decide 160.NumberOut True=Decide 160.NumberOut True + 1:NEXT(286$);

2244$         ASSIGN:        Decide 160.NumberOut False=Decide 160.NumberOut False + 1:NEXT(287$);


;
;
;     Model statements for module:  Assign 119
;
286$          ASSIGN:        receiptc1# c3=disc(0.848,0,0.859,1,0.880,2,0.902,3,0.935,4,0.962,5,0.973,6,0.989,7,0.995,8,1,10,81)
                             :NEXT(288$);


;
;
;     Model statements for module:  Decide 161
;
288$          BRANCH,        1:
                             If,receiptc1# c3==0,268$,Yes:
                             If,receiptc1# c3==1,289$,Yes:
                             Else,290$,Yes;

;
;
;     Model statements for module:  Separate 35
;
290$          DUPLICATE,     100 - 50:
                             receiptc1# c3-1,2249$,50:NEXT(2248$);

2248$         ASSIGN:        Separate 35.NumberOut Orig=Separate 35.NumberOut Orig + 1:NEXT(289$);

2249$         ASSIGN:        Separate 35.NumberOut Dup=Separate 35.NumberOut Dup + 1:NEXT(289$);


;
;
;     Model statements for module:  Process 40
;
289$          ASSIGN:        Process 40.NumberIn=Process 40.NumberIn + 1:
                             Process 40.WIP=Process 40.WIP+1;
2279$         STACK,         1:Save:NEXT(2253$);

2253$         QUEUE,         Process 40.Queue;
2252$         SEIZE,         2,VA:
                             Resource 28,1:NEXT(2251$);

2251$         DELAY:         HoursToBaseTime(expo(10/receiptc1# c3,17)),,VA:NEXT(2294$);

2294$         ASSIGN:        Process 40.WaitTime=Process 40.WaitTime + Diff.WaitTime;
2258$         TALLY:         Process 40.WaitTimePerEntity,Diff.WaitTime,1;
2260$         TALLY:         Process 40.TotalTimePerEntity,Diff.StartTime,1;
2284$         ASSIGN:        Process 40.VATime=Process 40.VATime + Diff.VATime;
2285$         TALLY:         Process 40.VATimePerEntity,Diff.VATime,1;
2250$         RELEASE:       Resource 28,1;
2299$         STACK,         1:Destroy:NEXT(2298$);

2298$         ASSIGN:        Process 40.NumberOut=Process 40.NumberOut + 1:
                             Process 40.WIP=Process 40.WIP-1:NEXT(265$);


;
;
;     Model statements for module:  Assign 114
;
265$          ASSIGN:        producttype=3:NEXT(157$);


;
;
;     Model statements for module:  Assign 120
;
287$          ASSIGN:        receiptc2# c3=disc(0.848,0,0.864,1,0.875,2,0.913,3,0.946,4,0.973,5,0.989,6,0.995,8,1,10,82)
                             :NEXT(291$);


;
;
;     Model statements for module:  Decide 162
;
291$          BRANCH,        1:
                             If,receiptc2# c3==0,268$,Yes:
                             If,receiptc2# c3==1,292$,Yes:
                             Else,293$,Yes;

;
;
;     Model statements for module:  Separate 36
;
293$          DUPLICATE,     100 - 50:
                             receiptc2# c3-1,2305$,50:NEXT(2304$);

2304$         ASSIGN:        Separate 36.NumberOut Orig=Separate 36.NumberOut Orig + 1:NEXT(292$);

2305$         ASSIGN:        Separate 36.NumberOut Dup=Separate 36.NumberOut Dup + 1:NEXT(292$);


;
;
;     Model statements for module:  Process 41
;
292$          ASSIGN:        Process 41.NumberIn=Process 41.NumberIn + 1:
                             Process 41.WIP=Process 41.WIP+1;
2335$         STACK,         1:Save:NEXT(2309$);

2309$         QUEUE,         Process 41.Queue;
2308$         SEIZE,         2,VA:
                             Resource 29,1:NEXT(2307$);

2307$         DELAY:         HoursToBaseTime(expo(14/receiptc2# c3,18)),,VA:NEXT(2350$);

2350$         ASSIGN:        Process 41.WaitTime=Process 41.WaitTime + Diff.WaitTime;
2314$         TALLY:         Process 41.WaitTimePerEntity,Diff.WaitTime,1;
2316$         TALLY:         Process 41.TotalTimePerEntity,Diff.StartTime,1;
2340$         ASSIGN:        Process 41.VATime=Process 41.VATime + Diff.VATime;
2341$         TALLY:         Process 41.VATimePerEntity,Diff.VATime,1;
2306$         RELEASE:       Resource 29,1;
2355$         STACK,         1:Destroy:NEXT(2354$);

2354$         ASSIGN:        Process 41.NumberOut=Process 41.NumberOut + 1:
                             Process 41.WIP=Process 41.WIP-1:NEXT(265$);


;
;
;     Model statements for module:  Create 48
;

2357$         CREATE,        1,MinutesToBaseTime(600.0001),Entity ra2rec# c3:MinutesToBaseTime(1440):NEXT(2358$);

2358$         ASSIGN:        Create for receiving a shift2 c3.NumberOut=Create for receiving a shift2 c3.NumberOut + 1
                             :NEXT(271$);


;
;
;     Model statements for module:  Decide 155
;
271$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2361$,Yes:
                             Else,2362$,Yes;
2361$         ASSIGN:        Decide 155.NumberOut True=Decide 155.NumberOut True + 1:NEXT(266$);

2362$         ASSIGN:        Decide 155.NumberOut False=Decide 155.NumberOut False + 1:NEXT(272$);


;
;
;     Model statements for module:  Assign 115
;
266$          ASSIGN:        receipta1# c3=
                             disc(0.772,0,0.777,2,0.788,4,0.810,5,0.821,6,0.832,7,0.870,8,0.886,9,0.891,10,0.908,11,0.924,12,0.935,13,0.946,14,0.951,16,0.962,17,0.973,18,0.978,22,0.984,23,0.995,27,1,32,77)
                             :NEXT(267$);


;
;
;     Model statements for module:  Decide 154
;
267$          BRANCH,        1:
                             If,receipta1# c3==0,268$,Yes:
                             If,receipta1# c3==1,269$,Yes:
                             Else,270$,Yes;

;
;
;     Model statements for module:  Separate 31
;
270$          DUPLICATE,     100 - 50:
                             receipta1# c3-1,2367$,50:NEXT(2366$);

2366$         ASSIGN:        Separate 31.NumberOut Orig=Separate 31.NumberOut Orig + 1:NEXT(269$);

2367$         ASSIGN:        Separate 31.NumberOut Dup=Separate 31.NumberOut Dup + 1:NEXT(269$);


;
;
;     Model statements for module:  Process 36
;
269$          ASSIGN:        Process 36.NumberIn=Process 36.NumberIn + 1:
                             Process 36.WIP=Process 36.WIP+1;
2397$         STACK,         1:Save:NEXT(2371$);

2371$         QUEUE,         Process 36.Queue;
2370$         SEIZE,         2,VA:
                             Resource 24,1:NEXT(2369$);

2369$         DELAY:         HoursToBaseTime(expo(10/receipta1# c3,13)),,VA:NEXT(2412$);

2412$         ASSIGN:        Process 36.WaitTime=Process 36.WaitTime + Diff.WaitTime;
2376$         TALLY:         Process 36.WaitTimePerEntity,Diff.WaitTime,1;
2378$         TALLY:         Process 36.TotalTimePerEntity,Diff.StartTime,1;
2402$         ASSIGN:        Process 36.VATime=Process 36.VATime + Diff.VATime;
2403$         TALLY:         Process 36.VATimePerEntity,Diff.VATime,1;
2368$         RELEASE:       Resource 24,1;
2417$         STACK,         1:Destroy:NEXT(2416$);

2416$         ASSIGN:        Process 36.NumberOut=Process 36.NumberOut + 1:
                             Process 36.WIP=Process 36.WIP-1:NEXT(263$);


;
;
;     Model statements for module:  Assign 112
;
263$          ASSIGN:        producttype=1:NEXT(157$);


;
;
;     Model statements for module:  Assign 116
;
272$          ASSIGN:        receipta2# c3=
                             disc(0.810,0,0.821,1,0.832,2,0.848,4,0.853,5,0.864,6,0.880,7,0.886,8,0.891,9,0.902,10,0.913,11,0.918,12,0.924,13,0.929,14,0.940,15,0.946,16,0.962,18,0.973,20,0.978,23,0.984,26,0.989,28,0.995,29,1,36,78)
                             :NEXT(273$);


;
;
;     Model statements for module:  Decide 156
;
273$          BRANCH,        1:
                             If,receipta2# c3==0,268$,Yes:
                             If,receipta2# c3==1,275$,Yes:
                             Else,274$,Yes;

;
;
;     Model statements for module:  Separate 32
;
274$          DUPLICATE,     100 - 50:
                             receipta2# c3-1,2423$,50:NEXT(2422$);

2422$         ASSIGN:        Separate 32.NumberOut Orig=Separate 32.NumberOut Orig + 1:NEXT(275$);

2423$         ASSIGN:        Separate 32.NumberOut Dup=Separate 32.NumberOut Dup + 1:NEXT(275$);


;
;
;     Model statements for module:  Process 37
;
275$          ASSIGN:        Process 37.NumberIn=Process 37.NumberIn + 1:
                             Process 37.WIP=Process 37.WIP+1;
2453$         STACK,         1:Save:NEXT(2427$);

2427$         QUEUE,         Process 37.Queue;
2426$         SEIZE,         2,VA:
                             Resource 25,1:NEXT(2425$);

2425$         DELAY:         HoursToBaseTime(expo(14/receipta2# c3,14)),,VA:NEXT(2468$);

2468$         ASSIGN:        Process 37.WaitTime=Process 37.WaitTime + Diff.WaitTime;
2432$         TALLY:         Process 37.WaitTimePerEntity,Diff.WaitTime,1;
2434$         TALLY:         Process 37.TotalTimePerEntity,Diff.StartTime,1;
2458$         ASSIGN:        Process 37.VATime=Process 37.VATime + Diff.VATime;
2459$         TALLY:         Process 37.VATimePerEntity,Diff.VATime,1;
2424$         RELEASE:       Resource 25,1;
2473$         STACK,         1:Destroy:NEXT(2472$);

2472$         ASSIGN:        Process 37.NumberOut=Process 37.NumberOut + 1:
                             Process 37.WIP=Process 37.WIP-1:NEXT(263$);


;
;
;     Model statements for module:  Create 49
;

2475$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rb2rec# c3:MinutesToBaseTime(1440):NEXT(2476$);

2476$         ASSIGN:        Create for receiving b shift2 c3.NumberOut=Create for receiving b shift2 c3.NumberOut + 1
                             :NEXT(276$);


;
;
;     Model statements for module:  Create 50
;

2479$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rc2rec# c3:MinutesToBaseTime(1440):NEXT(2480$);

2480$         ASSIGN:        Create for receiving c shift2 c3.NumberOut=Create for receiving c shift2 c3.NumberOut + 1
                             :NEXT(285$);


;
;
;     Model statements for module:  Create 54
;

2483$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sb1ship# c3:MinutesToBaseTime(1440):NEXT(2484$);

2484$         ASSIGN:        Create for shipment b shift1 c3.NumberOut=Create for shipment b shift1 c3.NumberOut + 1:NEXT(307$);


;
;
;     Model statements for module:  Decide 166
;
307$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2487$,Yes:
                             Else,2488$,Yes;
2487$         ASSIGN:        Decide 166.NumberOut True=Decide 166.NumberOut True + 1:NEXT(308$);

2488$         ASSIGN:        Decide 166.NumberOut False=Decide 166.NumberOut False + 1:NEXT(309$);


;
;
;     Model statements for module:  Assign 126
;
308$          ASSIGN:        departureb1# c3=disc(0.674,0,0.717,1,0.783,2,0.810,3,0.918,4,0.973,5,1,6,109):NEXT(310$);


;
;
;     Model statements for module:  Decide 167
;
310$          BRANCH,        1:
                             If,departureb1# c3==0,301$,Yes:
                             If,departureb1# c3==1,311$,Yes:
                             Else,312$,Yes;

;
;
;     Model statements for module:  Separate 39
;
312$          DUPLICATE,     100 - 50:
                             departureb1# c3-1,2493$,50:NEXT(2492$);

2492$         ASSIGN:        Separate 39.NumberOut Orig=Separate 39.NumberOut Orig + 1:NEXT(311$);

2493$         ASSIGN:        Separate 39.NumberOut Dup=Separate 39.NumberOut Dup + 1:NEXT(311$);


;
;
;     Model statements for module:  Process 44
;
311$          ASSIGN:        Process 44.NumberIn=Process 44.NumberIn + 1:
                             Process 44.WIP=Process 44.WIP+1;
2523$         STACK,         1:Save:NEXT(2497$);

2497$         QUEUE,         Process 44.Queue;
2496$         SEIZE,         2,VA:
                             Resource 32,1:NEXT(2495$);

2495$         DELAY:         HoursToBaseTime(expo(10/departureb1# c3,45)),,VA:NEXT(2538$);

2538$         ASSIGN:        Process 44.WaitTime=Process 44.WaitTime + Diff.WaitTime;
2502$         TALLY:         Process 44.WaitTimePerEntity,Diff.WaitTime,1;
2504$         TALLY:         Process 44.TotalTimePerEntity,Diff.StartTime,1;
2528$         ASSIGN:        Process 44.VATime=Process 44.VATime + Diff.VATime;
2529$         TALLY:         Process 44.VATimePerEntity,Diff.VATime,1;
2494$         RELEASE:       Resource 32,1;
2543$         STACK,         1:Destroy:NEXT(2542$);

2542$         ASSIGN:        Process 44.NumberOut=Process 44.NumberOut + 1:
                             Process 44.WIP=Process 44.WIP-1:NEXT(295$);


;
;
;     Model statements for module:  Assign 122
;
295$          ASSIGN:        type=2:NEXT(137$);


;
;
;     Model statements for module:  Dispose 26
;
301$          ASSIGN:        Dispose 26.NumberOut=Dispose 26.NumberOut + 1;
2545$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 127
;
309$          ASSIGN:        departureb2# c3=disc(0.663,0,0.707,1,0.761,2,0.853,3,0.891,4,0.946,5,0.973,6,0.995,7,1,9,110)
                             :NEXT(313$);


;
;
;     Model statements for module:  Decide 168
;
313$          BRANCH,        1:
                             If,departureb2# c3==0,301$,Yes:
                             If,departureb2# c3==1,314$,Yes:
                             Else,315$,Yes;

;
;
;     Model statements for module:  Separate 40
;
315$          DUPLICATE,     100 - 50:
                             departureb2# c3-1,2550$,50:NEXT(2549$);

2549$         ASSIGN:        Separate 40.NumberOut Orig=Separate 40.NumberOut Orig + 1:NEXT(314$);

2550$         ASSIGN:        Separate 40.NumberOut Dup=Separate 40.NumberOut Dup + 1:NEXT(314$);


;
;
;     Model statements for module:  Process 45
;
314$          ASSIGN:        Process 45.NumberIn=Process 45.NumberIn + 1:
                             Process 45.WIP=Process 45.WIP+1;
2580$         STACK,         1:Save:NEXT(2554$);

2554$         QUEUE,         Process 45.Queue;
2553$         SEIZE,         2,VA:
                             Resource 33,1:NEXT(2552$);

2552$         DELAY:         HoursToBaseTime(expo(14/departureb2# c3,46)),,VA:NEXT(2595$);

2595$         ASSIGN:        Process 45.WaitTime=Process 45.WaitTime + Diff.WaitTime;
2559$         TALLY:         Process 45.WaitTimePerEntity,Diff.WaitTime,1;
2561$         TALLY:         Process 45.TotalTimePerEntity,Diff.StartTime,1;
2585$         ASSIGN:        Process 45.VATime=Process 45.VATime + Diff.VATime;
2586$         TALLY:         Process 45.VATimePerEntity,Diff.VATime,1;
2551$         RELEASE:       Resource 33,1;
2600$         STACK,         1:Destroy:NEXT(2599$);

2599$         ASSIGN:        Process 45.NumberOut=Process 45.NumberOut + 1:
                             Process 45.WIP=Process 45.WIP-1:NEXT(295$);


;
;
;     Model statements for module:  Create 55
;

2602$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sc1ship# c3:MinutesToBaseTime(1440):NEXT(2603$);

2603$         ASSIGN:        Create for shipment c shift1 c3.NumberOut=Create for shipment c shift1 c3.NumberOut + 1:NEXT(316$);


;
;
;     Model statements for module:  Decide 169
;
316$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2606$,Yes:
                             Else,2607$,Yes;
2606$         ASSIGN:        Decide 169.NumberOut True=Decide 169.NumberOut True + 1:NEXT(317$);

2607$         ASSIGN:        Decide 169.NumberOut False=Decide 169.NumberOut False + 1:NEXT(318$);


;
;
;     Model statements for module:  Assign 128
;
317$          ASSIGN:        departurec1# c3=disc(0.842,0,0.891,1,0.924,2,0.935,3,0.962,4,0.978,5,0.995,6,1,7,111):NEXT(319$);


;
;
;     Model statements for module:  Decide 170
;
319$          BRANCH,        1:
                             If,departurec1# c3==0,301$,Yes:
                             If,departurec1# c3==1,320$,Yes:
                             Else,321$,Yes;

;
;
;     Model statements for module:  Separate 41
;
321$          DUPLICATE,     100 - 50:
                             departurec1# c3-1,2612$,50:NEXT(2611$);

2611$         ASSIGN:        Separate 41.NumberOut Orig=Separate 41.NumberOut Orig + 1:NEXT(320$);

2612$         ASSIGN:        Separate 41.NumberOut Dup=Separate 41.NumberOut Dup + 1:NEXT(320$);


;
;
;     Model statements for module:  Process 46
;
320$          ASSIGN:        Process 46.NumberIn=Process 46.NumberIn + 1:
                             Process 46.WIP=Process 46.WIP+1;
2642$         STACK,         1:Save:NEXT(2616$);

2616$         QUEUE,         Process 46.Queue;
2615$         SEIZE,         2,VA:
                             Resource 34,1:NEXT(2614$);

2614$         DELAY:         HoursToBaseTime(expo(10/departurec1# c3,47)),,VA:NEXT(2657$);

2657$         ASSIGN:        Process 46.WaitTime=Process 46.WaitTime + Diff.WaitTime;
2621$         TALLY:         Process 46.WaitTimePerEntity,Diff.WaitTime,1;
2623$         TALLY:         Process 46.TotalTimePerEntity,Diff.StartTime,1;
2647$         ASSIGN:        Process 46.VATime=Process 46.VATime + Diff.VATime;
2648$         TALLY:         Process 46.VATimePerEntity,Diff.VATime,1;
2613$         RELEASE:       Resource 34,1;
2662$         STACK,         1:Destroy:NEXT(2661$);

2661$         ASSIGN:        Process 46.NumberOut=Process 46.NumberOut + 1:
                             Process 46.WIP=Process 46.WIP-1:NEXT(296$);


;
;
;     Model statements for module:  Assign 123
;
296$          ASSIGN:        type=3:NEXT(137$);


;
;
;     Model statements for module:  Assign 129
;
318$          ASSIGN:        departurec2# c3=disc(0.723,0,0.804,1,0.870,2,0.908,3,0.940,4,0.989,5,1,6,112):NEXT(322$);


;
;
;     Model statements for module:  Decide 171
;
322$          BRANCH,        1:
                             If,departurec2# c3==0,301$,Yes:
                             If,departurec2# c3==1,323$,Yes:
                             Else,324$,Yes;

;
;
;     Model statements for module:  Separate 42
;
324$          DUPLICATE,     100 - 50:
                             departurec2# c3-1,2668$,50:NEXT(2667$);

2667$         ASSIGN:        Separate 42.NumberOut Orig=Separate 42.NumberOut Orig + 1:NEXT(323$);

2668$         ASSIGN:        Separate 42.NumberOut Dup=Separate 42.NumberOut Dup + 1:NEXT(323$);


;
;
;     Model statements for module:  Process 47
;
323$          ASSIGN:        Process 47.NumberIn=Process 47.NumberIn + 1:
                             Process 47.WIP=Process 47.WIP+1;
2698$         STACK,         1:Save:NEXT(2672$);

2672$         QUEUE,         Process 47.Queue;
2671$         SEIZE,         2,VA:
                             Resource 35,1:NEXT(2670$);

2670$         DELAY:         HoursToBaseTime(expo(14/departurec2# c3,48)),,VA:NEXT(2713$);

2713$         ASSIGN:        Process 47.WaitTime=Process 47.WaitTime + Diff.WaitTime;
2677$         TALLY:         Process 47.WaitTimePerEntity,Diff.WaitTime,1;
2679$         TALLY:         Process 47.TotalTimePerEntity,Diff.StartTime,1;
2703$         ASSIGN:        Process 47.VATime=Process 47.VATime + Diff.VATime;
2704$         TALLY:         Process 47.VATimePerEntity,Diff.VATime,1;
2669$         RELEASE:       Resource 35,1;
2718$         STACK,         1:Destroy:NEXT(2717$);

2717$         ASSIGN:        Process 47.NumberOut=Process 47.NumberOut + 1:
                             Process 47.WIP=Process 47.WIP-1:NEXT(296$);


;
;
;     Model statements for module:  Create 57
;

2720$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sa2ship# c3:MinutesToBaseTime(1440):NEXT(2721$);

2721$         ASSIGN:        Create for shipmenta shift2 c3.NumberOut=Create for shipmenta shift2 c3.NumberOut + 1:NEXT(298$);


;
;
;     Model statements for module:  Decide 163
;
298$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2724$,Yes:
                             Else,2725$,Yes;
2724$         ASSIGN:        Decide 163.NumberOut True=Decide 163.NumberOut True + 1:NEXT(297$);

2725$         ASSIGN:        Decide 163.NumberOut False=Decide 163.NumberOut False + 1:NEXT(299$);


;
;
;     Model statements for module:  Assign 124
;
297$          ASSIGN:        departurea1# c3=
                             disc(0.332,0,0.386,1,0.5,2,0.707,3,0.859,4,0.946,5,0.984,6,0.989,7,0.995,8,1,10,107):NEXT(300$);


;
;
;     Model statements for module:  Decide 164
;
300$          BRANCH,        1:
                             If,departurea1# c3==0,301$,Yes:
                             If,departurea1# c3==1,302$,Yes:
                             Else,303$,Yes;

;
;
;     Model statements for module:  Separate 37
;
303$          DUPLICATE,     100 - 50:
                             departurea1# c3-1,2730$,50:NEXT(2729$);

2729$         ASSIGN:        Separate 37.NumberOut Orig=Separate 37.NumberOut Orig + 1:NEXT(302$);

2730$         ASSIGN:        Separate 37.NumberOut Dup=Separate 37.NumberOut Dup + 1:NEXT(302$);


;
;
;     Model statements for module:  Process 42
;
302$          ASSIGN:        Process 42.NumberIn=Process 42.NumberIn + 1:
                             Process 42.WIP=Process 42.WIP+1;
2760$         STACK,         1:Save:NEXT(2734$);

2734$         QUEUE,         Process 42.Queue;
2733$         SEIZE,         2,VA:
                             Resource 30,1:NEXT(2732$);

2732$         DELAY:         HoursToBaseTime(expo(10/departurea1# c3,43)),,VA:NEXT(2775$);

2775$         ASSIGN:        Process 42.WaitTime=Process 42.WaitTime + Diff.WaitTime;
2739$         TALLY:         Process 42.WaitTimePerEntity,Diff.WaitTime,1;
2741$         TALLY:         Process 42.TotalTimePerEntity,Diff.StartTime,1;
2765$         ASSIGN:        Process 42.VATime=Process 42.VATime + Diff.VATime;
2766$         TALLY:         Process 42.VATimePerEntity,Diff.VATime,1;
2731$         RELEASE:       Resource 30,1;
2780$         STACK,         1:Destroy:NEXT(2779$);

2779$         ASSIGN:        Process 42.NumberOut=Process 42.NumberOut + 1:
                             Process 42.WIP=Process 42.WIP-1:NEXT(294$);


;
;
;     Model statements for module:  Assign 121
;
294$          ASSIGN:        type=1:NEXT(137$);


;
;
;     Model statements for module:  Assign 125
;
299$          ASSIGN:        departurea2# c3=disc(0.315,0,0.408,1,0.505,2,0.685,3,0.837,4,0.929,5,0.989,6,1,7,108):NEXT(304$);


;
;
;     Model statements for module:  Decide 165
;
304$          BRANCH,        1:
                             If,departurea2# c3==0,301$,Yes:
                             If,departurea2# c3==1,306$,Yes:
                             Else,305$,Yes;

;
;
;     Model statements for module:  Separate 38
;
305$          DUPLICATE,     100 - 50:
                             departurea2# c3-1,2786$,50:NEXT(2785$);

2785$         ASSIGN:        Separate 38.NumberOut Orig=Separate 38.NumberOut Orig + 1:NEXT(306$);

2786$         ASSIGN:        Separate 38.NumberOut Dup=Separate 38.NumberOut Dup + 1:NEXT(306$);


;
;
;     Model statements for module:  Process 43
;
306$          ASSIGN:        Process 43.NumberIn=Process 43.NumberIn + 1:
                             Process 43.WIP=Process 43.WIP+1;
2816$         STACK,         1:Save:NEXT(2790$);

2790$         QUEUE,         Process 43.Queue;
2789$         SEIZE,         2,VA:
                             Resource 31,1:NEXT(2788$);

2788$         DELAY:         HoursToBaseTime(expo(14/departurea2# c3,44)),,VA:NEXT(2831$);

2831$         ASSIGN:        Process 43.WaitTime=Process 43.WaitTime + Diff.WaitTime;
2795$         TALLY:         Process 43.WaitTimePerEntity,Diff.WaitTime,1;
2797$         TALLY:         Process 43.TotalTimePerEntity,Diff.StartTime,1;
2821$         ASSIGN:        Process 43.VATime=Process 43.VATime + Diff.VATime;
2822$         TALLY:         Process 43.VATimePerEntity,Diff.VATime,1;
2787$         RELEASE:       Resource 31,1;
2836$         STACK,         1:Destroy:NEXT(2835$);

2835$         ASSIGN:        Process 43.NumberOut=Process 43.NumberOut + 1:
                             Process 43.WIP=Process 43.WIP-1:NEXT(294$);


;
;
;     Model statements for module:  Create 58
;

2838$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sb2ship# c3:MinutesToBaseTime(1440):NEXT(2839$);

2839$         ASSIGN:        Create for shipment b shift2 c3.NumberOut=Create for shipment b shift2 c3.NumberOut + 1:NEXT(307$);


;
;
;     Model statements for module:  Create 60
;

2842$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rb1rec# c4:MinutesToBaseTime(1440):NEXT(2843$);

2843$         ASSIGN:        Create for receiving b shift1 c4.NumberOut=Create for receiving b shift1 c4.NumberOut + 1
                             :NEXT(338$);


;
;
;     Model statements for module:  Decide 175
;
338$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2846$,Yes:
                             Else,2847$,Yes;
2846$         ASSIGN:        Decide 175.NumberOut True=Decide 175.NumberOut True + 1:NEXT(339$);

2847$         ASSIGN:        Decide 175.NumberOut False=Decide 175.NumberOut False + 1:NEXT(340$);


;
;
;     Model statements for module:  Assign 135
;
339$          ASSIGN:        receiptb1# c4=
                             disc(0.924,0,0.929,1,0.940,2,0.946,6,0.951,8,0.962,9,0.973,15,0.978,16,0.984,17,0.989,18,0.995,19,1,21,85)
                             :NEXT(341$);


;
;
;     Model statements for module:  Decide 176
;
341$          BRANCH,        1:
                             If,receiptb1# c4==0,330$,Yes:
                             If,receiptb1# c4==1,342$,Yes:
                             Else,343$,Yes;

;
;
;     Model statements for module:  Separate 45
;
343$          DUPLICATE,     100 - 50:
                             receiptb1# c4-1,2852$,50:NEXT(2851$);

2851$         ASSIGN:        Separate 45.NumberOut Orig=Separate 45.NumberOut Orig + 1:NEXT(342$);

2852$         ASSIGN:        Separate 45.NumberOut Dup=Separate 45.NumberOut Dup + 1:NEXT(342$);


;
;
;     Model statements for module:  Process 50
;
342$          ASSIGN:        Process 50.NumberIn=Process 50.NumberIn + 1:
                             Process 50.WIP=Process 50.WIP+1;
2882$         STACK,         1:Save:NEXT(2856$);

2856$         QUEUE,         Process 50.Queue;
2855$         SEIZE,         2,VA:
                             Resource 38,1:NEXT(2854$);

2854$         DELAY:         HoursToBaseTime(expo(10/receiptb1# c4,21)),,VA:NEXT(2897$);

2897$         ASSIGN:        Process 50.WaitTime=Process 50.WaitTime + Diff.WaitTime;
2861$         TALLY:         Process 50.WaitTimePerEntity,Diff.WaitTime,1;
2863$         TALLY:         Process 50.TotalTimePerEntity,Diff.StartTime,1;
2887$         ASSIGN:        Process 50.VATime=Process 50.VATime + Diff.VATime;
2888$         TALLY:         Process 50.VATimePerEntity,Diff.VATime,1;
2853$         RELEASE:       Resource 38,1;
2902$         STACK,         1:Destroy:NEXT(2901$);

2901$         ASSIGN:        Process 50.NumberOut=Process 50.NumberOut + 1:
                             Process 50.WIP=Process 50.WIP-1:NEXT(326$);


;
;
;     Model statements for module:  Assign 131
;
326$          ASSIGN:        producttype=2:NEXT(157$);


;
;
;     Model statements for module:  Dispose 27
;
330$          ASSIGN:        Dispose 27.NumberOut=Dispose 27.NumberOut + 1;
2904$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 136
;
340$          ASSIGN:        receiptb2# c4=
                             disc(0.929,0,0.935,1,0.946,7,0.957,8,0.967,12,0.973,15,0.978,17,0.984,19,0.989,21,0.995,27,1,28,86)
                             :NEXT(344$);


;
;
;     Model statements for module:  Decide 177
;
344$          BRANCH,        1:
                             If,receiptb2# c4==0,330$,Yes:
                             If,receiptb2# c4==1,345$,Yes:
                             Else,346$,Yes;

;
;
;     Model statements for module:  Separate 46
;
346$          DUPLICATE,     100 - 50:
                             receiptb2# c4-1,2909$,50:NEXT(2908$);

2908$         ASSIGN:        Separate 46.NumberOut Orig=Separate 46.NumberOut Orig + 1:NEXT(345$);

2909$         ASSIGN:        Separate 46.NumberOut Dup=Separate 46.NumberOut Dup + 1:NEXT(345$);


;
;
;     Model statements for module:  Process 51
;
345$          ASSIGN:        Process 51.NumberIn=Process 51.NumberIn + 1:
                             Process 51.WIP=Process 51.WIP+1;
2939$         STACK,         1:Save:NEXT(2913$);

2913$         QUEUE,         Process 51.Queue;
2912$         SEIZE,         2,VA:
                             Resource 39,1:NEXT(2911$);

2911$         DELAY:         HoursToBaseTime(expo(14/receiptb2# c4,22)),,VA:NEXT(2954$);

2954$         ASSIGN:        Process 51.WaitTime=Process 51.WaitTime + Diff.WaitTime;
2918$         TALLY:         Process 51.WaitTimePerEntity,Diff.WaitTime,1;
2920$         TALLY:         Process 51.TotalTimePerEntity,Diff.StartTime,1;
2944$         ASSIGN:        Process 51.VATime=Process 51.VATime + Diff.VATime;
2945$         TALLY:         Process 51.VATimePerEntity,Diff.VATime,1;
2910$         RELEASE:       Resource 39,1;
2959$         STACK,         1:Destroy:NEXT(2958$);

2958$         ASSIGN:        Process 51.NumberOut=Process 51.NumberOut + 1:
                             Process 51.WIP=Process 51.WIP-1:NEXT(326$);


;
;
;     Model statements for module:  Create 61
;

2961$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rc1rec# c4:MinutesToBaseTime(1440):NEXT(2962$);

2962$         ASSIGN:        Create for receiving c shift1 c4.NumberOut=Create for receiving c shift1 c4.NumberOut + 1
                             :NEXT(347$);


;
;
;     Model statements for module:  Decide 178
;
347$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),2965$,Yes:
                             Else,2966$,Yes;
2965$         ASSIGN:        Decide 178.NumberOut True=Decide 178.NumberOut True + 1:NEXT(348$);

2966$         ASSIGN:        Decide 178.NumberOut False=Decide 178.NumberOut False + 1:NEXT(349$);


;
;
;     Model statements for module:  Assign 137
;
348$          ASSIGN:        receiptc1# c4=disc(0.848,0,0.859,1,0.880,2,0.902,3,0.935,4,0.962,5,0.973,6,0.989,7,0.995,8,1,10,87)
                             :NEXT(350$);


;
;
;     Model statements for module:  Decide 179
;
350$          BRANCH,        1:
                             If,receiptc1# c4==0,330$,Yes:
                             If,receiptc1# c4==1,351$,Yes:
                             Else,352$,Yes;

;
;
;     Model statements for module:  Separate 47
;
352$          DUPLICATE,     100 - 50:
                             receiptc1# c4-1,2971$,50:NEXT(2970$);

2970$         ASSIGN:        Separate 47.NumberOut Orig=Separate 47.NumberOut Orig + 1:NEXT(351$);

2971$         ASSIGN:        Separate 47.NumberOut Dup=Separate 47.NumberOut Dup + 1:NEXT(351$);


;
;
;     Model statements for module:  Process 52
;
351$          ASSIGN:        Process 52.NumberIn=Process 52.NumberIn + 1:
                             Process 52.WIP=Process 52.WIP+1;
3001$         STACK,         1:Save:NEXT(2975$);

2975$         QUEUE,         Process 52.Queue;
2974$         SEIZE,         2,VA:
                             Resource 40,1:NEXT(2973$);

2973$         DELAY:         HoursToBaseTime(expo(10/receiptc1# c4,23)),,VA:NEXT(3016$);

3016$         ASSIGN:        Process 52.WaitTime=Process 52.WaitTime + Diff.WaitTime;
2980$         TALLY:         Process 52.WaitTimePerEntity,Diff.WaitTime,1;
2982$         TALLY:         Process 52.TotalTimePerEntity,Diff.StartTime,1;
3006$         ASSIGN:        Process 52.VATime=Process 52.VATime + Diff.VATime;
3007$         TALLY:         Process 52.VATimePerEntity,Diff.VATime,1;
2972$         RELEASE:       Resource 40,1;
3021$         STACK,         1:Destroy:NEXT(3020$);

3020$         ASSIGN:        Process 52.NumberOut=Process 52.NumberOut + 1:
                             Process 52.WIP=Process 52.WIP-1:NEXT(327$);


;
;
;     Model statements for module:  Assign 132
;
327$          ASSIGN:        producttype=3:NEXT(157$);


;
;
;     Model statements for module:  Assign 138
;
349$          ASSIGN:        receiptc2# c4=disc(0.848,0,0.864,1,0.875,2,0.913,3,0.946,4,0.973,5,0.989,6,0.995,8,1,10,88)
                             :NEXT(353$);


;
;
;     Model statements for module:  Decide 180
;
353$          BRANCH,        1:
                             If,receiptc2# c4==0,330$,Yes:
                             If,receiptc2# c4==1,354$,Yes:
                             Else,355$,Yes;

;
;
;     Model statements for module:  Separate 48
;
355$          DUPLICATE,     100 - 50:
                             receiptc2# c4-1,3027$,50:NEXT(3026$);

3026$         ASSIGN:        Separate 48.NumberOut Orig=Separate 48.NumberOut Orig + 1:NEXT(354$);

3027$         ASSIGN:        Separate 48.NumberOut Dup=Separate 48.NumberOut Dup + 1:NEXT(354$);


;
;
;     Model statements for module:  Process 53
;
354$          ASSIGN:        Process 53.NumberIn=Process 53.NumberIn + 1:
                             Process 53.WIP=Process 53.WIP+1;
3057$         STACK,         1:Save:NEXT(3031$);

3031$         QUEUE,         Process 53.Queue;
3030$         SEIZE,         2,VA:
                             Resource 41,1:NEXT(3029$);

3029$         DELAY:         HoursToBaseTime(expo(14/receiptc2# c4,24)),,VA:NEXT(3072$);

3072$         ASSIGN:        Process 53.WaitTime=Process 53.WaitTime + Diff.WaitTime;
3036$         TALLY:         Process 53.WaitTimePerEntity,Diff.WaitTime,1;
3038$         TALLY:         Process 53.TotalTimePerEntity,Diff.StartTime,1;
3062$         ASSIGN:        Process 53.VATime=Process 53.VATime + Diff.VATime;
3063$         TALLY:         Process 53.VATimePerEntity,Diff.VATime,1;
3028$         RELEASE:       Resource 41,1;
3077$         STACK,         1:Destroy:NEXT(3076$);

3076$         ASSIGN:        Process 53.NumberOut=Process 53.NumberOut + 1:
                             Process 53.WIP=Process 53.WIP-1:NEXT(327$);


;
;
;     Model statements for module:  Create 63
;

3079$         CREATE,        1,MinutesToBaseTime(600.0001),Entity ra2rec# c4:MinutesToBaseTime(1440):NEXT(3080$);

3080$         ASSIGN:        Create for receiving a shift2 c4.NumberOut=Create for receiving a shift2 c4.NumberOut + 1
                             :NEXT(333$);


;
;
;     Model statements for module:  Decide 173
;
333$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3083$,Yes:
                             Else,3084$,Yes;
3083$         ASSIGN:        Decide 173.NumberOut True=Decide 173.NumberOut True + 1:NEXT(328$);

3084$         ASSIGN:        Decide 173.NumberOut False=Decide 173.NumberOut False + 1:NEXT(334$);


;
;
;     Model statements for module:  Assign 133
;
328$          ASSIGN:        receipta1# c4=
                             disc(0.772,0,0.777,2,0.788,4,0.810,5,0.821,6,0.832,7,0.870,8,0.886,9,0.891,10,0.908,11,0.924,12,0.935,13,0.946,14,0.951,16,0.962,17,0.973,18,0.978,22,0.984,23,0.995,27,1,32,83)
                             :NEXT(329$);


;
;
;     Model statements for module:  Decide 172
;
329$          BRANCH,        1:
                             If,receipta1# c4==0,330$,Yes:
                             If,receipta1# c4==1,331$,Yes:
                             Else,332$,Yes;

;
;
;     Model statements for module:  Separate 43
;
332$          DUPLICATE,     100 - 50:
                             receipta1# c4-1,3089$,50:NEXT(3088$);

3088$         ASSIGN:        Separate 43.NumberOut Orig=Separate 43.NumberOut Orig + 1:NEXT(331$);

3089$         ASSIGN:        Separate 43.NumberOut Dup=Separate 43.NumberOut Dup + 1:NEXT(331$);


;
;
;     Model statements for module:  Process 48
;
331$          ASSIGN:        Process 48.NumberIn=Process 48.NumberIn + 1:
                             Process 48.WIP=Process 48.WIP+1;
3119$         STACK,         1:Save:NEXT(3093$);

3093$         QUEUE,         Process 48.Queue;
3092$         SEIZE,         2,VA:
                             Resource 36,1:NEXT(3091$);

3091$         DELAY:         HoursToBaseTime(expo(10/receipta1# c4,19)),,VA:NEXT(3134$);

3134$         ASSIGN:        Process 48.WaitTime=Process 48.WaitTime + Diff.WaitTime;
3098$         TALLY:         Process 48.WaitTimePerEntity,Diff.WaitTime,1;
3100$         TALLY:         Process 48.TotalTimePerEntity,Diff.StartTime,1;
3124$         ASSIGN:        Process 48.VATime=Process 48.VATime + Diff.VATime;
3125$         TALLY:         Process 48.VATimePerEntity,Diff.VATime,1;
3090$         RELEASE:       Resource 36,1;
3139$         STACK,         1:Destroy:NEXT(3138$);

3138$         ASSIGN:        Process 48.NumberOut=Process 48.NumberOut + 1:
                             Process 48.WIP=Process 48.WIP-1:NEXT(325$);


;
;
;     Model statements for module:  Assign 130
;
325$          ASSIGN:        producttype=1:NEXT(157$);


;
;
;     Model statements for module:  Assign 134
;
334$          ASSIGN:        receipta2# c4=
                             disc(0.810,0,0.821,1,0.832,2,0.848,4,0.853,5,0.864,6,0.880,7,0.886,8,0.891,9,0.902,10,0.913,11,0.918,12,0.924,13,0.929,14,0.940,15,0.946,16,0.962,18,0.973,20,0.978,23,0.984,26,0.989,28,0.995,29,1,36,84)
                             :NEXT(335$);


;
;
;     Model statements for module:  Decide 174
;
335$          BRANCH,        1:
                             If,receipta2# c4==0,330$,Yes:
                             If,receipta2# c4==1,337$,Yes:
                             Else,336$,Yes;

;
;
;     Model statements for module:  Separate 44
;
336$          DUPLICATE,     100 - 50:
                             receipta2# c4-1,3145$,50:NEXT(3144$);

3144$         ASSIGN:        Separate 44.NumberOut Orig=Separate 44.NumberOut Orig + 1:NEXT(337$);

3145$         ASSIGN:        Separate 44.NumberOut Dup=Separate 44.NumberOut Dup + 1:NEXT(337$);


;
;
;     Model statements for module:  Process 49
;
337$          ASSIGN:        Process 49.NumberIn=Process 49.NumberIn + 1:
                             Process 49.WIP=Process 49.WIP+1;
3175$         STACK,         1:Save:NEXT(3149$);

3149$         QUEUE,         Process 49.Queue;
3148$         SEIZE,         2,VA:
                             Resource 37,1:NEXT(3147$);

3147$         DELAY:         HoursToBaseTime(expo(14/receipta2# c4,20)),,VA:NEXT(3190$);

3190$         ASSIGN:        Process 49.WaitTime=Process 49.WaitTime + Diff.WaitTime;
3154$         TALLY:         Process 49.WaitTimePerEntity,Diff.WaitTime,1;
3156$         TALLY:         Process 49.TotalTimePerEntity,Diff.StartTime,1;
3180$         ASSIGN:        Process 49.VATime=Process 49.VATime + Diff.VATime;
3181$         TALLY:         Process 49.VATimePerEntity,Diff.VATime,1;
3146$         RELEASE:       Resource 37,1;
3195$         STACK,         1:Destroy:NEXT(3194$);

3194$         ASSIGN:        Process 49.NumberOut=Process 49.NumberOut + 1:
                             Process 49.WIP=Process 49.WIP-1:NEXT(325$);


;
;
;     Model statements for module:  Create 64
;

3197$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rb2rec# c4:MinutesToBaseTime(1440):NEXT(3198$);

3198$         ASSIGN:        Create for receiving b shift2 c4.NumberOut=Create for receiving b shift2 c4.NumberOut + 1
                             :NEXT(338$);


;
;
;     Model statements for module:  Create 65
;

3201$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rc2rec# c4:MinutesToBaseTime(1440):NEXT(3202$);

3202$         ASSIGN:        Create for receiving c shift2 c4.NumberOut=Create for receiving c shift2 c4.NumberOut + 1
                             :NEXT(347$);


;
;
;     Model statements for module:  Create 69
;

3205$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sb1ship# c4:MinutesToBaseTime(1440):NEXT(3206$);

3206$         ASSIGN:        Create for shipment b shift1 c4.NumberOut=Create for shipment b shift1 c4.NumberOut + 1:NEXT(369$);


;
;
;     Model statements for module:  Decide 184
;
369$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3209$,Yes:
                             Else,3210$,Yes;
3209$         ASSIGN:        Decide 184.NumberOut True=Decide 184.NumberOut True + 1:NEXT(370$);

3210$         ASSIGN:        Decide 184.NumberOut False=Decide 184.NumberOut False + 1:NEXT(371$);


;
;
;     Model statements for module:  Assign 144
;
370$          ASSIGN:        departureb1# c4=disc(0.674,0,0.717,1,0.783,2,0.810,3,0.918,4,0.973,5,1,6,115):NEXT(372$);


;
;
;     Model statements for module:  Decide 185
;
372$          BRANCH,        1:
                             If,departureb1# c4==0,363$,Yes:
                             If,departureb1# c4==1,373$,Yes:
                             Else,374$,Yes;

;
;
;     Model statements for module:  Separate 51
;
374$          DUPLICATE,     100 - 50:
                             departureb1# c4-1,3215$,50:NEXT(3214$);

3214$         ASSIGN:        Separate 51.NumberOut Orig=Separate 51.NumberOut Orig + 1:NEXT(373$);

3215$         ASSIGN:        Separate 51.NumberOut Dup=Separate 51.NumberOut Dup + 1:NEXT(373$);


;
;
;     Model statements for module:  Process 56
;
373$          ASSIGN:        Process 56.NumberIn=Process 56.NumberIn + 1:
                             Process 56.WIP=Process 56.WIP+1;
3245$         STACK,         1:Save:NEXT(3219$);

3219$         QUEUE,         Process 56.Queue;
3218$         SEIZE,         2,VA:
                             Resource 44,1:NEXT(3217$);

3217$         DELAY:         HoursToBaseTime(expo(10/departureb1# c4,51)),,VA:NEXT(3260$);

3260$         ASSIGN:        Process 56.WaitTime=Process 56.WaitTime + Diff.WaitTime;
3224$         TALLY:         Process 56.WaitTimePerEntity,Diff.WaitTime,1;
3226$         TALLY:         Process 56.TotalTimePerEntity,Diff.StartTime,1;
3250$         ASSIGN:        Process 56.VATime=Process 56.VATime + Diff.VATime;
3251$         TALLY:         Process 56.VATimePerEntity,Diff.VATime,1;
3216$         RELEASE:       Resource 44,1;
3265$         STACK,         1:Destroy:NEXT(3264$);

3264$         ASSIGN:        Process 56.NumberOut=Process 56.NumberOut + 1:
                             Process 56.WIP=Process 56.WIP-1:NEXT(357$);


;
;
;     Model statements for module:  Assign 140
;
357$          ASSIGN:        type=2:NEXT(137$);


;
;
;     Model statements for module:  Dispose 28
;
363$          ASSIGN:        Dispose 28.NumberOut=Dispose 28.NumberOut + 1;
3267$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 145
;
371$          ASSIGN:        departureb2# c4=disc(0.663,0,0.707,1,0.761,2,0.853,3,0.891,4,0.946,5,0.973,6,0.995,7,1,9,116)
                             :NEXT(375$);


;
;
;     Model statements for module:  Decide 186
;
375$          BRANCH,        1:
                             If,departureb2# c4==0,363$,Yes:
                             If,departureb2# c4==1,376$,Yes:
                             Else,377$,Yes;

;
;
;     Model statements for module:  Separate 52
;
377$          DUPLICATE,     100 - 50:
                             departureb2# c4-1,3272$,50:NEXT(3271$);

3271$         ASSIGN:        Separate 52.NumberOut Orig=Separate 52.NumberOut Orig + 1:NEXT(376$);

3272$         ASSIGN:        Separate 52.NumberOut Dup=Separate 52.NumberOut Dup + 1:NEXT(376$);


;
;
;     Model statements for module:  Process 57
;
376$          ASSIGN:        Process 57.NumberIn=Process 57.NumberIn + 1:
                             Process 57.WIP=Process 57.WIP+1;
3302$         STACK,         1:Save:NEXT(3276$);

3276$         QUEUE,         Process 57.Queue;
3275$         SEIZE,         2,VA:
                             Resource 45,1:NEXT(3274$);

3274$         DELAY:         HoursToBaseTime(expo(14/departureb2# c4,52)),,VA:NEXT(3317$);

3317$         ASSIGN:        Process 57.WaitTime=Process 57.WaitTime + Diff.WaitTime;
3281$         TALLY:         Process 57.WaitTimePerEntity,Diff.WaitTime,1;
3283$         TALLY:         Process 57.TotalTimePerEntity,Diff.StartTime,1;
3307$         ASSIGN:        Process 57.VATime=Process 57.VATime + Diff.VATime;
3308$         TALLY:         Process 57.VATimePerEntity,Diff.VATime,1;
3273$         RELEASE:       Resource 45,1;
3322$         STACK,         1:Destroy:NEXT(3321$);

3321$         ASSIGN:        Process 57.NumberOut=Process 57.NumberOut + 1:
                             Process 57.WIP=Process 57.WIP-1:NEXT(357$);


;
;
;     Model statements for module:  Create 70
;

3324$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sc1ship# c4:MinutesToBaseTime(1440):NEXT(3325$);

3325$         ASSIGN:        Create for shipment c shift1 c4.NumberOut=Create for shipment c shift1 c4.NumberOut + 1:NEXT(378$);


;
;
;     Model statements for module:  Decide 187
;
378$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3328$,Yes:
                             Else,3329$,Yes;
3328$         ASSIGN:        Decide 187.NumberOut True=Decide 187.NumberOut True + 1:NEXT(379$);

3329$         ASSIGN:        Decide 187.NumberOut False=Decide 187.NumberOut False + 1:NEXT(380$);


;
;
;     Model statements for module:  Assign 146
;
379$          ASSIGN:        departurec1# c4=disc(0.842,0,0.891,1,0.924,2,0.935,3,0.962,4,0.978,5,0.995,6,1,7,117):NEXT(381$);


;
;
;     Model statements for module:  Decide 188
;
381$          BRANCH,        1:
                             If,departurec1# c4==0,363$,Yes:
                             If,departurec1# c4==1,382$,Yes:
                             Else,383$,Yes;

;
;
;     Model statements for module:  Separate 53
;
383$          DUPLICATE,     100 - 50:
                             departurec1# c4-1,3334$,50:NEXT(3333$);

3333$         ASSIGN:        Separate 53.NumberOut Orig=Separate 53.NumberOut Orig + 1:NEXT(382$);

3334$         ASSIGN:        Separate 53.NumberOut Dup=Separate 53.NumberOut Dup + 1:NEXT(382$);


;
;
;     Model statements for module:  Process 58
;
382$          ASSIGN:        Process 58.NumberIn=Process 58.NumberIn + 1:
                             Process 58.WIP=Process 58.WIP+1;
3364$         STACK,         1:Save:NEXT(3338$);

3338$         QUEUE,         Process 58.Queue;
3337$         SEIZE,         2,VA:
                             Resource 46,1:NEXT(3336$);

3336$         DELAY:         HoursToBaseTime(expo(10/departurec1# c4,53)),,VA:NEXT(3379$);

3379$         ASSIGN:        Process 58.WaitTime=Process 58.WaitTime + Diff.WaitTime;
3343$         TALLY:         Process 58.WaitTimePerEntity,Diff.WaitTime,1;
3345$         TALLY:         Process 58.TotalTimePerEntity,Diff.StartTime,1;
3369$         ASSIGN:        Process 58.VATime=Process 58.VATime + Diff.VATime;
3370$         TALLY:         Process 58.VATimePerEntity,Diff.VATime,1;
3335$         RELEASE:       Resource 46,1;
3384$         STACK,         1:Destroy:NEXT(3383$);

3383$         ASSIGN:        Process 58.NumberOut=Process 58.NumberOut + 1:
                             Process 58.WIP=Process 58.WIP-1:NEXT(358$);


;
;
;     Model statements for module:  Assign 141
;
358$          ASSIGN:        type=3:NEXT(137$);


;
;
;     Model statements for module:  Assign 147
;
380$          ASSIGN:        departurec2# c4=disc(0.723,0,0.804,1,0.870,2,0.908,3,0.940,4,0.989,5,1,6,118):NEXT(384$);


;
;
;     Model statements for module:  Decide 189
;
384$          BRANCH,        1:
                             If,departurec2# c4==0,363$,Yes:
                             If,departurec2# c4==1,385$,Yes:
                             Else,386$,Yes;

;
;
;     Model statements for module:  Separate 54
;
386$          DUPLICATE,     100 - 50:
                             departurec2# c4-1,3390$,50:NEXT(3389$);

3389$         ASSIGN:        Separate 54.NumberOut Orig=Separate 54.NumberOut Orig + 1:NEXT(385$);

3390$         ASSIGN:        Separate 54.NumberOut Dup=Separate 54.NumberOut Dup + 1:NEXT(385$);


;
;
;     Model statements for module:  Process 59
;
385$          ASSIGN:        Process 59.NumberIn=Process 59.NumberIn + 1:
                             Process 59.WIP=Process 59.WIP+1;
3420$         STACK,         1:Save:NEXT(3394$);

3394$         QUEUE,         Process 59.Queue;
3393$         SEIZE,         2,VA:
                             Resource 47,1:NEXT(3392$);

3392$         DELAY:         HoursToBaseTime(expo(14/departurec2# c4,54)),,VA:NEXT(3435$);

3435$         ASSIGN:        Process 59.WaitTime=Process 59.WaitTime + Diff.WaitTime;
3399$         TALLY:         Process 59.WaitTimePerEntity,Diff.WaitTime,1;
3401$         TALLY:         Process 59.TotalTimePerEntity,Diff.StartTime,1;
3425$         ASSIGN:        Process 59.VATime=Process 59.VATime + Diff.VATime;
3426$         TALLY:         Process 59.VATimePerEntity,Diff.VATime,1;
3391$         RELEASE:       Resource 47,1;
3440$         STACK,         1:Destroy:NEXT(3439$);

3439$         ASSIGN:        Process 59.NumberOut=Process 59.NumberOut + 1:
                             Process 59.WIP=Process 59.WIP-1:NEXT(358$);


;
;
;     Model statements for module:  Create 72
;

3442$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sa2ship# c4:MinutesToBaseTime(1440):NEXT(3443$);

3443$         ASSIGN:        Create for shipmenta shift2 c4.NumberOut=Create for shipmenta shift2 c4.NumberOut + 1:NEXT(360$);


;
;
;     Model statements for module:  Decide 181
;
360$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3446$,Yes:
                             Else,3447$,Yes;
3446$         ASSIGN:        Decide 181.NumberOut True=Decide 181.NumberOut True + 1:NEXT(359$);

3447$         ASSIGN:        Decide 181.NumberOut False=Decide 181.NumberOut False + 1:NEXT(361$);


;
;
;     Model statements for module:  Assign 142
;
359$          ASSIGN:        departurea1# c4=
                             disc(0.332,0,0.386,1,0.5,2,0.707,3,0.859,4,0.946,5,0.984,6,0.989,7,0.995,8,1,10,113):NEXT(362$);


;
;
;     Model statements for module:  Decide 182
;
362$          BRANCH,        1:
                             If,departurea1# c4==0,363$,Yes:
                             If,departurea1# c4==1,364$,Yes:
                             Else,365$,Yes;

;
;
;     Model statements for module:  Separate 49
;
365$          DUPLICATE,     100 - 50:
                             departurea1# c4-1,3452$,50:NEXT(3451$);

3451$         ASSIGN:        Separate 49.NumberOut Orig=Separate 49.NumberOut Orig + 1:NEXT(364$);

3452$         ASSIGN:        Separate 49.NumberOut Dup=Separate 49.NumberOut Dup + 1:NEXT(364$);


;
;
;     Model statements for module:  Process 54
;
364$          ASSIGN:        Process 54.NumberIn=Process 54.NumberIn + 1:
                             Process 54.WIP=Process 54.WIP+1;
3482$         STACK,         1:Save:NEXT(3456$);

3456$         QUEUE,         Process 54.Queue;
3455$         SEIZE,         2,VA:
                             Resource 42,1:NEXT(3454$);

3454$         DELAY:         HoursToBaseTime(expo(10/departurea1# c4,49)),,VA:NEXT(3497$);

3497$         ASSIGN:        Process 54.WaitTime=Process 54.WaitTime + Diff.WaitTime;
3461$         TALLY:         Process 54.WaitTimePerEntity,Diff.WaitTime,1;
3463$         TALLY:         Process 54.TotalTimePerEntity,Diff.StartTime,1;
3487$         ASSIGN:        Process 54.VATime=Process 54.VATime + Diff.VATime;
3488$         TALLY:         Process 54.VATimePerEntity,Diff.VATime,1;
3453$         RELEASE:       Resource 42,1;
3502$         STACK,         1:Destroy:NEXT(3501$);

3501$         ASSIGN:        Process 54.NumberOut=Process 54.NumberOut + 1:
                             Process 54.WIP=Process 54.WIP-1:NEXT(356$);


;
;
;     Model statements for module:  Assign 139
;
356$          ASSIGN:        type=1:NEXT(137$);


;
;
;     Model statements for module:  Assign 143
;
361$          ASSIGN:        departurea2# c4=disc(0.315,0,0.408,1,0.505,2,0.685,3,0.837,4,0.929,5,0.989,6,1,7,114):NEXT(366$);


;
;
;     Model statements for module:  Decide 183
;
366$          BRANCH,        1:
                             If,departurea2# c4==0,363$,Yes:
                             If,departurea2# c4==1,368$,Yes:
                             Else,367$,Yes;

;
;
;     Model statements for module:  Separate 50
;
367$          DUPLICATE,     100 - 50:
                             departurea2# c4-1,3508$,50:NEXT(3507$);

3507$         ASSIGN:        Separate 50.NumberOut Orig=Separate 50.NumberOut Orig + 1:NEXT(368$);

3508$         ASSIGN:        Separate 50.NumberOut Dup=Separate 50.NumberOut Dup + 1:NEXT(368$);


;
;
;     Model statements for module:  Process 55
;
368$          ASSIGN:        Process 55.NumberIn=Process 55.NumberIn + 1:
                             Process 55.WIP=Process 55.WIP+1;
3538$         STACK,         1:Save:NEXT(3512$);

3512$         QUEUE,         Process 55.Queue;
3511$         SEIZE,         2,VA:
                             Resource 43,1:NEXT(3510$);

3510$         DELAY:         HoursToBaseTime(expo(14/departurea2# c4,50)),,VA:NEXT(3553$);

3553$         ASSIGN:        Process 55.WaitTime=Process 55.WaitTime + Diff.WaitTime;
3517$         TALLY:         Process 55.WaitTimePerEntity,Diff.WaitTime,1;
3519$         TALLY:         Process 55.TotalTimePerEntity,Diff.StartTime,1;
3543$         ASSIGN:        Process 55.VATime=Process 55.VATime + Diff.VATime;
3544$         TALLY:         Process 55.VATimePerEntity,Diff.VATime,1;
3509$         RELEASE:       Resource 43,1;
3558$         STACK,         1:Destroy:NEXT(3557$);

3557$         ASSIGN:        Process 55.NumberOut=Process 55.NumberOut + 1:
                             Process 55.WIP=Process 55.WIP-1:NEXT(356$);


;
;
;     Model statements for module:  Create 73
;

3560$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sb2ship# c4:MinutesToBaseTime(1440):NEXT(3561$);

3561$         ASSIGN:        Create for shipment b shift2 c4.NumberOut=Create for shipment b shift2 c4.NumberOut + 1:NEXT(369$);


;
;
;     Model statements for module:  Create 84
;

3564$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rb1rec# c5:MinutesToBaseTime(1440):NEXT(3565$);

3565$         ASSIGN:        Create for receiving b shift1 c5.NumberOut=Create for receiving b shift1 c5.NumberOut + 1
                             :NEXT(400$);


;
;
;     Model statements for module:  Decide 202
;
400$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3568$,Yes:
                             Else,3569$,Yes;
3568$         ASSIGN:        Decide 202.NumberOut True=Decide 202.NumberOut True + 1:NEXT(401$);

3569$         ASSIGN:        Decide 202.NumberOut False=Decide 202.NumberOut False + 1:NEXT(402$);


;
;
;     Model statements for module:  Assign 162
;
401$          ASSIGN:        receiptb1# c5=
                             disc(0.924,0,0.929,1,0.940,2,0.946,6,0.951,8,0.962,9,0.973,15,0.978,16,0.984,17,0.989,18,0.995,19,1,21,91)
                             :NEXT(403$);


;
;
;     Model statements for module:  Decide 203
;
403$          BRANCH,        1:
                             If,receiptb1# c5==0,392$,Yes:
                             If,receiptb1# c5==1,404$,Yes:
                             Else,405$,Yes;

;
;
;     Model statements for module:  Separate 63
;
405$          DUPLICATE,     100 - 50:
                             receiptb1# c5-1,3574$,50:NEXT(3573$);

3573$         ASSIGN:        Separate 63.NumberOut Orig=Separate 63.NumberOut Orig + 1:NEXT(404$);

3574$         ASSIGN:        Separate 63.NumberOut Dup=Separate 63.NumberOut Dup + 1:NEXT(404$);


;
;
;     Model statements for module:  Process 68
;
404$          ASSIGN:        Process 68.NumberIn=Process 68.NumberIn + 1:
                             Process 68.WIP=Process 68.WIP+1;
3604$         STACK,         1:Save:NEXT(3578$);

3578$         QUEUE,         Process 68.Queue;
3577$         SEIZE,         2,VA:
                             Resource 50,1:NEXT(3576$);

3576$         DELAY:         HoursToBaseTime(expo(10/receiptb1# c5,27)),,VA:NEXT(3619$);

3619$         ASSIGN:        Process 68.WaitTime=Process 68.WaitTime + Diff.WaitTime;
3583$         TALLY:         Process 68.WaitTimePerEntity,Diff.WaitTime,1;
3585$         TALLY:         Process 68.TotalTimePerEntity,Diff.StartTime,1;
3609$         ASSIGN:        Process 68.VATime=Process 68.VATime + Diff.VATime;
3610$         TALLY:         Process 68.VATimePerEntity,Diff.VATime,1;
3575$         RELEASE:       Resource 50,1;
3624$         STACK,         1:Destroy:NEXT(3623$);

3623$         ASSIGN:        Process 68.NumberOut=Process 68.NumberOut + 1:
                             Process 68.WIP=Process 68.WIP-1:NEXT(388$);


;
;
;     Model statements for module:  Assign 158
;
388$          ASSIGN:        producttype=2:NEXT(157$);


;
;
;     Model statements for module:  Dispose 30
;
392$          ASSIGN:        Dispose 30.NumberOut=Dispose 30.NumberOut + 1;
3626$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 163
;
402$          ASSIGN:        receiptb2# c5=
                             disc(0.929,0,0.935,1,0.946,7,0.957,8,0.967,12,0.973,15,0.978,17,0.984,19,0.989,21,0.995,27,1,28,92)
                             :NEXT(406$);


;
;
;     Model statements for module:  Decide 204
;
406$          BRANCH,        1:
                             If,receiptb2# c5==0,392$,Yes:
                             If,receiptb2# c5==1,407$,Yes:
                             Else,408$,Yes;

;
;
;     Model statements for module:  Separate 64
;
408$          DUPLICATE,     100 - 50:
                             receiptb2# c5-1,3631$,50:NEXT(3630$);

3630$         ASSIGN:        Separate 64.NumberOut Orig=Separate 64.NumberOut Orig + 1:NEXT(407$);

3631$         ASSIGN:        Separate 64.NumberOut Dup=Separate 64.NumberOut Dup + 1:NEXT(407$);


;
;
;     Model statements for module:  Process 69
;
407$          ASSIGN:        Process 69.NumberIn=Process 69.NumberIn + 1:
                             Process 69.WIP=Process 69.WIP+1;
3661$         STACK,         1:Save:NEXT(3635$);

3635$         QUEUE,         Process 69.Queue;
3634$         SEIZE,         2,VA:
                             Resource 51,1:NEXT(3633$);

3633$         DELAY:         HoursToBaseTime(expo(14/receiptb2# c5,28)),,VA:NEXT(3676$);

3676$         ASSIGN:        Process 69.WaitTime=Process 69.WaitTime + Diff.WaitTime;
3640$         TALLY:         Process 69.WaitTimePerEntity,Diff.WaitTime,1;
3642$         TALLY:         Process 69.TotalTimePerEntity,Diff.StartTime,1;
3666$         ASSIGN:        Process 69.VATime=Process 69.VATime + Diff.VATime;
3667$         TALLY:         Process 69.VATimePerEntity,Diff.VATime,1;
3632$         RELEASE:       Resource 51,1;
3681$         STACK,         1:Destroy:NEXT(3680$);

3680$         ASSIGN:        Process 69.NumberOut=Process 69.NumberOut + 1:
                             Process 69.WIP=Process 69.WIP-1:NEXT(388$);


;
;
;     Model statements for module:  Create 85
;

3683$         CREATE,        1,MinutesToBaseTime(0.0001),Entity rc1rec# c5:MinutesToBaseTime(1440):NEXT(3684$);

3684$         ASSIGN:        Create for receiving c shift1 c5.NumberOut=Create for receiving c shift1 c5.NumberOut + 1
                             :NEXT(409$);


;
;
;     Model statements for module:  Decide 205
;
409$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3687$,Yes:
                             Else,3688$,Yes;
3687$         ASSIGN:        Decide 205.NumberOut True=Decide 205.NumberOut True + 1:NEXT(410$);

3688$         ASSIGN:        Decide 205.NumberOut False=Decide 205.NumberOut False + 1:NEXT(411$);


;
;
;     Model statements for module:  Assign 164
;
410$          ASSIGN:        receiptc1# c5=disc(0.848,0,0.859,1,0.880,2,0.902,3,0.935,4,0.962,5,0.973,6,0.989,7,0.995,8,1,10,93)
                             :NEXT(412$);


;
;
;     Model statements for module:  Decide 206
;
412$          BRANCH,        1:
                             If,receiptc1# c5==0,392$,Yes:
                             If,receiptc1# c5==1,413$,Yes:
                             Else,414$,Yes;

;
;
;     Model statements for module:  Separate 65
;
414$          DUPLICATE,     100 - 50:
                             receiptc1# c5-1,3693$,50:NEXT(3692$);

3692$         ASSIGN:        Separate 65.NumberOut Orig=Separate 65.NumberOut Orig + 1:NEXT(413$);

3693$         ASSIGN:        Separate 65.NumberOut Dup=Separate 65.NumberOut Dup + 1:NEXT(413$);


;
;
;     Model statements for module:  Process 70
;
413$          ASSIGN:        Process 70.NumberIn=Process 70.NumberIn + 1:
                             Process 70.WIP=Process 70.WIP+1;
3723$         STACK,         1:Save:NEXT(3697$);

3697$         QUEUE,         Process 70.Queue;
3696$         SEIZE,         2,VA:
                             Resource 52,1:NEXT(3695$);

3695$         DELAY:         HoursToBaseTime(expo(10/receiptc1# c5,29)),,VA:NEXT(3738$);

3738$         ASSIGN:        Process 70.WaitTime=Process 70.WaitTime + Diff.WaitTime;
3702$         TALLY:         Process 70.WaitTimePerEntity,Diff.WaitTime,1;
3704$         TALLY:         Process 70.TotalTimePerEntity,Diff.StartTime,1;
3728$         ASSIGN:        Process 70.VATime=Process 70.VATime + Diff.VATime;
3729$         TALLY:         Process 70.VATimePerEntity,Diff.VATime,1;
3694$         RELEASE:       Resource 52,1;
3743$         STACK,         1:Destroy:NEXT(3742$);

3742$         ASSIGN:        Process 70.NumberOut=Process 70.NumberOut + 1:
                             Process 70.WIP=Process 70.WIP-1:NEXT(389$);


;
;
;     Model statements for module:  Assign 159
;
389$          ASSIGN:        producttype=3:NEXT(157$);


;
;
;     Model statements for module:  Assign 165
;
411$          ASSIGN:        receiptc2# c5=disc(0.848,0,0.864,1,0.875,2,0.913,3,0.946,4,0.973,5,0.989,6,0.995,8,1,10,94)
                             :NEXT(415$);


;
;
;     Model statements for module:  Decide 207
;
415$          BRANCH,        1:
                             If,receiptc2# c5==0,392$,Yes:
                             If,receiptc2# c5==1,416$,Yes:
                             Else,417$,Yes;

;
;
;     Model statements for module:  Separate 66
;
417$          DUPLICATE,     100 - 50:
                             receiptc2# c5-1,3749$,50:NEXT(3748$);

3748$         ASSIGN:        Separate 66.NumberOut Orig=Separate 66.NumberOut Orig + 1:NEXT(416$);

3749$         ASSIGN:        Separate 66.NumberOut Dup=Separate 66.NumberOut Dup + 1:NEXT(416$);


;
;
;     Model statements for module:  Process 71
;
416$          ASSIGN:        Process 71.NumberIn=Process 71.NumberIn + 1:
                             Process 71.WIP=Process 71.WIP+1;
3779$         STACK,         1:Save:NEXT(3753$);

3753$         QUEUE,         Process 71.Queue;
3752$         SEIZE,         2,VA:
                             Resource 53,1:NEXT(3751$);

3751$         DELAY:         HoursToBaseTime(expo(14/receiptc2# c5,30)),,VA:NEXT(3794$);

3794$         ASSIGN:        Process 71.WaitTime=Process 71.WaitTime + Diff.WaitTime;
3758$         TALLY:         Process 71.WaitTimePerEntity,Diff.WaitTime,1;
3760$         TALLY:         Process 71.TotalTimePerEntity,Diff.StartTime,1;
3784$         ASSIGN:        Process 71.VATime=Process 71.VATime + Diff.VATime;
3785$         TALLY:         Process 71.VATimePerEntity,Diff.VATime,1;
3750$         RELEASE:       Resource 53,1;
3799$         STACK,         1:Destroy:NEXT(3798$);

3798$         ASSIGN:        Process 71.NumberOut=Process 71.NumberOut + 1:
                             Process 71.WIP=Process 71.WIP-1:NEXT(389$);


;
;
;     Model statements for module:  Create 87
;

3801$         CREATE,        1,MinutesToBaseTime(600.0001),Entity ra2rec# c5:MinutesToBaseTime(1440):NEXT(3802$);

3802$         ASSIGN:        Create for receiving a shift2 c5.NumberOut=Create for receiving a shift2 c5.NumberOut + 1
                             :NEXT(395$);


;
;
;     Model statements for module:  Decide 200
;
395$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3805$,Yes:
                             Else,3806$,Yes;
3805$         ASSIGN:        Decide 200.NumberOut True=Decide 200.NumberOut True + 1:NEXT(390$);

3806$         ASSIGN:        Decide 200.NumberOut False=Decide 200.NumberOut False + 1:NEXT(396$);


;
;
;     Model statements for module:  Assign 160
;
390$          ASSIGN:        receipta1# c5=
                             disc(0.772,0,0.777,2,0.788,4,0.810,5,0.821,6,0.832,7,0.870,8,0.886,9,0.891,10,0.908,11,0.924,12,0.935,13,0.946,14,0.951,16,0.962,17,0.973,18,0.978,22,0.984,23,0.995,27,1,32,89)
                             :NEXT(391$);


;
;
;     Model statements for module:  Decide 199
;
391$          BRANCH,        1:
                             If,receipta1# c5==0,392$,Yes:
                             If,receipta1# c5==1,393$,Yes:
                             Else,394$,Yes;

;
;
;     Model statements for module:  Separate 61
;
394$          DUPLICATE,     100 - 50:
                             receipta1# c5-1,3811$,50:NEXT(3810$);

3810$         ASSIGN:        Separate 61.NumberOut Orig=Separate 61.NumberOut Orig + 1:NEXT(393$);

3811$         ASSIGN:        Separate 61.NumberOut Dup=Separate 61.NumberOut Dup + 1:NEXT(393$);


;
;
;     Model statements for module:  Process 66
;
393$          ASSIGN:        Process 66.NumberIn=Process 66.NumberIn + 1:
                             Process 66.WIP=Process 66.WIP+1;
3841$         STACK,         1:Save:NEXT(3815$);

3815$         QUEUE,         Process 66.Queue;
3814$         SEIZE,         2,VA:
                             Resource 48,1:NEXT(3813$);

3813$         DELAY:         HoursToBaseTime(expo(10/receipta1# c5,25)),,VA:NEXT(3856$);

3856$         ASSIGN:        Process 66.WaitTime=Process 66.WaitTime + Diff.WaitTime;
3820$         TALLY:         Process 66.WaitTimePerEntity,Diff.WaitTime,1;
3822$         TALLY:         Process 66.TotalTimePerEntity,Diff.StartTime,1;
3846$         ASSIGN:        Process 66.VATime=Process 66.VATime + Diff.VATime;
3847$         TALLY:         Process 66.VATimePerEntity,Diff.VATime,1;
3812$         RELEASE:       Resource 48,1;
3861$         STACK,         1:Destroy:NEXT(3860$);

3860$         ASSIGN:        Process 66.NumberOut=Process 66.NumberOut + 1:
                             Process 66.WIP=Process 66.WIP-1:NEXT(387$);


;
;
;     Model statements for module:  Assign 157
;
387$          ASSIGN:        producttype=1:NEXT(157$);


;
;
;     Model statements for module:  Assign 161
;
396$          ASSIGN:        receipta2# c5=
                             disc(0.810,0,0.821,1,0.832,2,0.848,4,0.853,5,0.864,6,0.880,7,0.886,8,0.891,9,0.902,10,0.913,11,0.918,12,0.924,13,0.929,14,0.940,15,0.946,16,0.962,18,0.973,20,0.978,23,0.984,26,0.989,28,0.995,29,1,36,90)
                             :NEXT(397$);


;
;
;     Model statements for module:  Decide 201
;
397$          BRANCH,        1:
                             If,receipta2# c5==0,392$,Yes:
                             If,receipta2# c5==1,399$,Yes:
                             Else,398$,Yes;

;
;
;     Model statements for module:  Separate 62
;
398$          DUPLICATE,     100 - 50:
                             receipta2# c5-1,3867$,50:NEXT(3866$);

3866$         ASSIGN:        Separate 62.NumberOut Orig=Separate 62.NumberOut Orig + 1:NEXT(399$);

3867$         ASSIGN:        Separate 62.NumberOut Dup=Separate 62.NumberOut Dup + 1:NEXT(399$);


;
;
;     Model statements for module:  Process 67
;
399$          ASSIGN:        Process 67.NumberIn=Process 67.NumberIn + 1:
                             Process 67.WIP=Process 67.WIP+1;
3897$         STACK,         1:Save:NEXT(3871$);

3871$         QUEUE,         Process 67.Queue;
3870$         SEIZE,         2,VA:
                             Resource 49,1:NEXT(3869$);

3869$         DELAY:         HoursToBaseTime(expo(14/receipta2# c5,26)),,VA:NEXT(3912$);

3912$         ASSIGN:        Process 67.WaitTime=Process 67.WaitTime + Diff.WaitTime;
3876$         TALLY:         Process 67.WaitTimePerEntity,Diff.WaitTime,1;
3878$         TALLY:         Process 67.TotalTimePerEntity,Diff.StartTime,1;
3902$         ASSIGN:        Process 67.VATime=Process 67.VATime + Diff.VATime;
3903$         TALLY:         Process 67.VATimePerEntity,Diff.VATime,1;
3868$         RELEASE:       Resource 49,1;
3917$         STACK,         1:Destroy:NEXT(3916$);

3916$         ASSIGN:        Process 67.NumberOut=Process 67.NumberOut + 1:
                             Process 67.WIP=Process 67.WIP-1:NEXT(387$);


;
;
;     Model statements for module:  Create 88
;

3919$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rb2rec# c5:MinutesToBaseTime(1440):NEXT(3920$);

3920$         ASSIGN:        Create for receiving b shift2 c5.NumberOut=Create for receiving b shift2 c5.NumberOut + 1
                             :NEXT(400$);


;
;
;     Model statements for module:  Create 89
;

3923$         CREATE,        1,MinutesToBaseTime(600.0001),Entity rc2rec# c5:MinutesToBaseTime(1440):NEXT(3924$);

3924$         ASSIGN:        Create for receiving c shift2 c5.NumberOut=Create for receiving c shift2 c5.NumberOut + 1
                             :NEXT(409$);


;
;
;     Model statements for module:  Create 93
;

3927$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sb1ship# c5:MinutesToBaseTime(1440):NEXT(3928$);

3928$         ASSIGN:        Create for shipment b shift1 c5.NumberOut=Create for shipment b shift1 c5.NumberOut + 1:NEXT(431$);


;
;
;     Model statements for module:  Decide 211
;
431$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),3931$,Yes:
                             Else,3932$,Yes;
3931$         ASSIGN:        Decide 211.NumberOut True=Decide 211.NumberOut True + 1:NEXT(432$);

3932$         ASSIGN:        Decide 211.NumberOut False=Decide 211.NumberOut False + 1:NEXT(433$);


;
;
;     Model statements for module:  Assign 171
;
432$          ASSIGN:        departureb1# c5=disc(0.674,0,0.717,1,0.783,2,0.810,3,0.918,4,0.973,5,1,6,121):NEXT(434$);


;
;
;     Model statements for module:  Decide 212
;
434$          BRANCH,        1:
                             If,departureb1# c5==0,425$,Yes:
                             If,departureb1# c5==1,435$,Yes:
                             Else,436$,Yes;

;
;
;     Model statements for module:  Separate 69
;
436$          DUPLICATE,     100 - 50:
                             departureb1# c5-1,3937$,50:NEXT(3936$);

3936$         ASSIGN:        Separate 69.NumberOut Orig=Separate 69.NumberOut Orig + 1:NEXT(435$);

3937$         ASSIGN:        Separate 69.NumberOut Dup=Separate 69.NumberOut Dup + 1:NEXT(435$);


;
;
;     Model statements for module:  Process 74
;
435$          ASSIGN:        Process 74.NumberIn=Process 74.NumberIn + 1:
                             Process 74.WIP=Process 74.WIP+1;
3967$         STACK,         1:Save:NEXT(3941$);

3941$         QUEUE,         Process 74.Queue;
3940$         SEIZE,         2,VA:
                             Resource 56,1:NEXT(3939$);

3939$         DELAY:         HoursToBaseTime(expo(10/departureb1# c5,57)),,VA:NEXT(3982$);

3982$         ASSIGN:        Process 74.WaitTime=Process 74.WaitTime + Diff.WaitTime;
3946$         TALLY:         Process 74.WaitTimePerEntity,Diff.WaitTime,1;
3948$         TALLY:         Process 74.TotalTimePerEntity,Diff.StartTime,1;
3972$         ASSIGN:        Process 74.VATime=Process 74.VATime + Diff.VATime;
3973$         TALLY:         Process 74.VATimePerEntity,Diff.VATime,1;
3938$         RELEASE:       Resource 56,1;
3987$         STACK,         1:Destroy:NEXT(3986$);

3986$         ASSIGN:        Process 74.NumberOut=Process 74.NumberOut + 1:
                             Process 74.WIP=Process 74.WIP-1:NEXT(419$);


;
;
;     Model statements for module:  Assign 167
;
419$          ASSIGN:        type=2:NEXT(137$);


;
;
;     Model statements for module:  Dispose 31
;
425$          ASSIGN:        Dispose 31.NumberOut=Dispose 31.NumberOut + 1;
3989$         DISPOSE:       Yes;


;
;
;     Model statements for module:  Assign 172
;
433$          ASSIGN:        departureb2# c5=disc(0.663,0,0.707,1,0.761,2,0.853,3,0.891,4,0.946,5,0.973,6,0.995,7,1,9,122)
                             :NEXT(437$);


;
;
;     Model statements for module:  Decide 213
;
437$          BRANCH,        1:
                             If,departureb2# c5==0,425$,Yes:
                             If,departureb2# c5==1,438$,Yes:
                             Else,439$,Yes;

;
;
;     Model statements for module:  Separate 70
;
439$          DUPLICATE,     100 - 50:
                             departureb2# c5-1,3994$,50:NEXT(3993$);

3993$         ASSIGN:        Separate 70.NumberOut Orig=Separate 70.NumberOut Orig + 1:NEXT(438$);

3994$         ASSIGN:        Separate 70.NumberOut Dup=Separate 70.NumberOut Dup + 1:NEXT(438$);


;
;
;     Model statements for module:  Process 75
;
438$          ASSIGN:        Process 75.NumberIn=Process 75.NumberIn + 1:
                             Process 75.WIP=Process 75.WIP+1;
4024$         STACK,         1:Save:NEXT(3998$);

3998$         QUEUE,         Process 75.Queue;
3997$         SEIZE,         2,VA:
                             Resource 57,1:NEXT(3996$);

3996$         DELAY:         HoursToBaseTime(expo(14/departureb2# c5,58)),,VA:NEXT(4039$);

4039$         ASSIGN:        Process 75.WaitTime=Process 75.WaitTime + Diff.WaitTime;
4003$         TALLY:         Process 75.WaitTimePerEntity,Diff.WaitTime,1;
4005$         TALLY:         Process 75.TotalTimePerEntity,Diff.StartTime,1;
4029$         ASSIGN:        Process 75.VATime=Process 75.VATime + Diff.VATime;
4030$         TALLY:         Process 75.VATimePerEntity,Diff.VATime,1;
3995$         RELEASE:       Resource 57,1;
4044$         STACK,         1:Destroy:NEXT(4043$);

4043$         ASSIGN:        Process 75.NumberOut=Process 75.NumberOut + 1:
                             Process 75.WIP=Process 75.WIP-1:NEXT(419$);


;
;
;     Model statements for module:  Create 94
;

4046$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sc1ship# c5:MinutesToBaseTime(1440):NEXT(4047$);

4047$         ASSIGN:        Create for shipment c shift1 c5.NumberOut=Create for shipment c shift1 c5.NumberOut + 1:NEXT(440$);


;
;
;     Model statements for module:  Decide 214
;
440$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),4050$,Yes:
                             Else,4051$,Yes;
4050$         ASSIGN:        Decide 214.NumberOut True=Decide 214.NumberOut True + 1:NEXT(441$);

4051$         ASSIGN:        Decide 214.NumberOut False=Decide 214.NumberOut False + 1:NEXT(442$);


;
;
;     Model statements for module:  Assign 173
;
441$          ASSIGN:        departurec1# c5=disc(0.842,0,0.891,1,0.924,2,0.935,3,0.962,4,0.978,5,0.995,6,1,7,123):NEXT(443$);


;
;
;     Model statements for module:  Decide 215
;
443$          BRANCH,        1:
                             If,departurec1# c5==0,425$,Yes:
                             If,departurec1# c5==1,444$,Yes:
                             Else,445$,Yes;

;
;
;     Model statements for module:  Separate 71
;
445$          DUPLICATE,     100 - 50:
                             departurec1# c5-1,4056$,50:NEXT(4055$);

4055$         ASSIGN:        Separate 71.NumberOut Orig=Separate 71.NumberOut Orig + 1:NEXT(444$);

4056$         ASSIGN:        Separate 71.NumberOut Dup=Separate 71.NumberOut Dup + 1:NEXT(444$);


;
;
;     Model statements for module:  Process 76
;
444$          ASSIGN:        Process 76.NumberIn=Process 76.NumberIn + 1:
                             Process 76.WIP=Process 76.WIP+1;
4086$         STACK,         1:Save:NEXT(4060$);

4060$         QUEUE,         Process 76.Queue;
4059$         SEIZE,         2,VA:
                             Resource 58,1:NEXT(4058$);

4058$         DELAY:         HoursToBaseTime(expo(10/departurec1# c5,59)),,VA:NEXT(4101$);

4101$         ASSIGN:        Process 76.WaitTime=Process 76.WaitTime + Diff.WaitTime;
4065$         TALLY:         Process 76.WaitTimePerEntity,Diff.WaitTime,1;
4067$         TALLY:         Process 76.TotalTimePerEntity,Diff.StartTime,1;
4091$         ASSIGN:        Process 76.VATime=Process 76.VATime + Diff.VATime;
4092$         TALLY:         Process 76.VATimePerEntity,Diff.VATime,1;
4057$         RELEASE:       Resource 58,1;
4106$         STACK,         1:Destroy:NEXT(4105$);

4105$         ASSIGN:        Process 76.NumberOut=Process 76.NumberOut + 1:
                             Process 76.WIP=Process 76.WIP-1:NEXT(420$);


;
;
;     Model statements for module:  Assign 168
;
420$          ASSIGN:        type=3:NEXT(137$);


;
;
;     Model statements for module:  Assign 174
;
442$          ASSIGN:        departurec2# c5=disc(0.723,0,0.804,1,0.870,2,0.908,3,0.940,4,0.989,5,1,6,124):NEXT(446$);


;
;
;     Model statements for module:  Decide 216
;
446$          BRANCH,        1:
                             If,departurec2# c5==0,425$,Yes:
                             If,departurec2# c5==1,447$,Yes:
                             Else,448$,Yes;

;
;
;     Model statements for module:  Separate 72
;
448$          DUPLICATE,     100 - 50:
                             departurec2# c5-1,4112$,50:NEXT(4111$);

4111$         ASSIGN:        Separate 72.NumberOut Orig=Separate 72.NumberOut Orig + 1:NEXT(447$);

4112$         ASSIGN:        Separate 72.NumberOut Dup=Separate 72.NumberOut Dup + 1:NEXT(447$);


;
;
;     Model statements for module:  Process 77
;
447$          ASSIGN:        Process 77.NumberIn=Process 77.NumberIn + 1:
                             Process 77.WIP=Process 77.WIP+1;
4142$         STACK,         1:Save:NEXT(4116$);

4116$         QUEUE,         Process 77.Queue;
4115$         SEIZE,         2,VA:
                             Resource 59,1:NEXT(4114$);

4114$         DELAY:         HoursToBaseTime(expo(14/departurec2# c5,60)),,VA:NEXT(4157$);

4157$         ASSIGN:        Process 77.WaitTime=Process 77.WaitTime + Diff.WaitTime;
4121$         TALLY:         Process 77.WaitTimePerEntity,Diff.WaitTime,1;
4123$         TALLY:         Process 77.TotalTimePerEntity,Diff.StartTime,1;
4147$         ASSIGN:        Process 77.VATime=Process 77.VATime + Diff.VATime;
4148$         TALLY:         Process 77.VATimePerEntity,Diff.VATime,1;
4113$         RELEASE:       Resource 59,1;
4162$         STACK,         1:Destroy:NEXT(4161$);

4161$         ASSIGN:        Process 77.NumberOut=Process 77.NumberOut + 1:
                             Process 77.WIP=Process 77.WIP-1:NEXT(420$);


;
;
;     Model statements for module:  Create 96
;

4164$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sa2ship# c5:MinutesToBaseTime(1440):NEXT(4165$);

4165$         ASSIGN:        Create for shipmenta shift2 c5.NumberOut=Create for shipmenta shift2 c5.NumberOut + 1:NEXT(422$);


;
;
;     Model statements for module:  Decide 208
;
422$          BRANCH,        1:
                             If,((0+((day)*1440))<=tnow)&&(tnow<=(600+((day)*1440))),4168$,Yes:
                             Else,4169$,Yes;
4168$         ASSIGN:        Decide 208.NumberOut True=Decide 208.NumberOut True + 1:NEXT(421$);

4169$         ASSIGN:        Decide 208.NumberOut False=Decide 208.NumberOut False + 1:NEXT(423$);


;
;
;     Model statements for module:  Assign 169
;
421$          ASSIGN:        departurea1# c5=
                             disc(0.332,0,0.386,1,0.5,2,0.707,3,0.859,4,0.946,5,0.984,6,0.989,7,0.995,8,1,10,119):NEXT(424$);


;
;
;     Model statements for module:  Decide 209
;
424$          BRANCH,        1:
                             If,departurea1# c5==0,425$,Yes:
                             If,departurea1# c5==1,426$,Yes:
                             Else,427$,Yes;

;
;
;     Model statements for module:  Separate 67
;
427$          DUPLICATE,     100 - 50:
                             departurea1# c5-1,4174$,50:NEXT(4173$);

4173$         ASSIGN:        Separate 67.NumberOut Orig=Separate 67.NumberOut Orig + 1:NEXT(426$);

4174$         ASSIGN:        Separate 67.NumberOut Dup=Separate 67.NumberOut Dup + 1:NEXT(426$);


;
;
;     Model statements for module:  Process 72
;
426$          ASSIGN:        Process 72.NumberIn=Process 72.NumberIn + 1:
                             Process 72.WIP=Process 72.WIP+1;
4204$         STACK,         1:Save:NEXT(4178$);

4178$         QUEUE,         Process 72.Queue;
4177$         SEIZE,         2,VA:
                             Resource 54,1:NEXT(4176$);

4176$         DELAY:         HoursToBaseTime(expo(10/departurea1# c5,55)),,VA:NEXT(4219$);

4219$         ASSIGN:        Process 72.WaitTime=Process 72.WaitTime + Diff.WaitTime;
4183$         TALLY:         Process 72.WaitTimePerEntity,Diff.WaitTime,1;
4185$         TALLY:         Process 72.TotalTimePerEntity,Diff.StartTime,1;
4209$         ASSIGN:        Process 72.VATime=Process 72.VATime + Diff.VATime;
4210$         TALLY:         Process 72.VATimePerEntity,Diff.VATime,1;
4175$         RELEASE:       Resource 54,1;
4224$         STACK,         1:Destroy:NEXT(4223$);

4223$         ASSIGN:        Process 72.NumberOut=Process 72.NumberOut + 1:
                             Process 72.WIP=Process 72.WIP-1:NEXT(418$);


;
;
;     Model statements for module:  Assign 166
;
418$          ASSIGN:        type=1:NEXT(137$);


;
;
;     Model statements for module:  Assign 170
;
423$          ASSIGN:        departurea2# c5=disc(0.315,0,0.408,1,0.505,2,0.685,3,0.837,4,0.929,5,0.989,6,1,7,120):NEXT(428$);


;
;
;     Model statements for module:  Decide 210
;
428$          BRANCH,        1:
                             If,departurea2# c5==0,425$,Yes:
                             If,departurea2# c5==1,430$,Yes:
                             Else,429$,Yes;

;
;
;     Model statements for module:  Separate 68
;
429$          DUPLICATE,     100 - 50:
                             departurea2# c5-1,4230$,50:NEXT(4229$);

4229$         ASSIGN:        Separate 68.NumberOut Orig=Separate 68.NumberOut Orig + 1:NEXT(430$);

4230$         ASSIGN:        Separate 68.NumberOut Dup=Separate 68.NumberOut Dup + 1:NEXT(430$);


;
;
;     Model statements for module:  Process 73
;
430$          ASSIGN:        Process 73.NumberIn=Process 73.NumberIn + 1:
                             Process 73.WIP=Process 73.WIP+1;
4260$         STACK,         1:Save:NEXT(4234$);

4234$         QUEUE,         Process 73.Queue;
4233$         SEIZE,         2,VA:
                             Resource 55,1:NEXT(4232$);

4232$         DELAY:         HoursToBaseTime(expo(14/departurea2# c5,56)),,VA:NEXT(4275$);

4275$         ASSIGN:        Process 73.WaitTime=Process 73.WaitTime + Diff.WaitTime;
4239$         TALLY:         Process 73.WaitTimePerEntity,Diff.WaitTime,1;
4241$         TALLY:         Process 73.TotalTimePerEntity,Diff.StartTime,1;
4265$         ASSIGN:        Process 73.VATime=Process 73.VATime + Diff.VATime;
4266$         TALLY:         Process 73.VATimePerEntity,Diff.VATime,1;
4231$         RELEASE:       Resource 55,1;
4280$         STACK,         1:Destroy:NEXT(4279$);

4279$         ASSIGN:        Process 73.NumberOut=Process 73.NumberOut + 1:
                             Process 73.WIP=Process 73.WIP-1:NEXT(418$);


;
;
;     Model statements for module:  Create 97
;

4282$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sb2ship# c5:MinutesToBaseTime(1440):NEXT(4283$);

4283$         ASSIGN:        Create for shipment b shift2 c5.NumberOut=Create for shipment b shift2 c5.NumberOut + 1:NEXT(431$);


;
;
;     Model statements for module:  Create 99
;

4286$         CREATE,        1,MinutesToBaseTime(0.0001),Entity ra1rec# c2:MinutesToBaseTime(1440):NEXT(4287$);

4287$         ASSIGN:        Create for receiving a shift1 c2.NumberOut=Create for receiving a shift1 c2.NumberOut + 1
                             :NEXT(206$);


;
;
;     Model statements for module:  Create 100
;

4290$         CREATE,        1,MinutesToBaseTime(0.0001),Entity ra1rec# c1:MinutesToBaseTime(1440):NEXT(4291$);

4291$         ASSIGN:        Create for receiving a shift1 c1.NumberOut=Create for receiving a shift1 c1.NumberOut + 1:NEXT(79$);


;
;
;     Model statements for module:  Create 101
;

4294$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sa1ship# c1:MinutesToBaseTime(1440):NEXT(4295$);

4295$         ASSIGN:        Create for shipmenta shift1 c1.NumberOut=Create for shipmenta shift1 c1.NumberOut + 1:NEXT(84$);


;
;
;     Model statements for module:  Create 102
;

4298$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sa1ship# c2:MinutesToBaseTime(1440):NEXT(4299$);

4299$         ASSIGN:        Create for shipmenta shift1 c2.NumberOut=Create for shipmenta shift1 c2.NumberOut + 1:NEXT(232$);


;
;
;     Model statements for module:  Create 103
;

4302$         CREATE,        1,MinutesToBaseTime(0.0001),Entity ra1rec# c3:MinutesToBaseTime(1440):NEXT(4303$);

4303$         ASSIGN:        Create for receiving a shift1 c3.NumberOut=Create for receiving a shift1 c3.NumberOut + 1
                             :NEXT(271$);


;
;
;     Model statements for module:  Create 104
;

4306$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sa1ship# c3:MinutesToBaseTime(1440):NEXT(4307$);

4307$         ASSIGN:        Create for shipmenta shift1 c3.NumberOut=Create for shipmenta shift1 c3.NumberOut + 1:NEXT(298$);


;
;
;     Model statements for module:  Create 105
;

4310$         CREATE,        1,MinutesToBaseTime(0.0001),Entity ra1rec# c4:MinutesToBaseTime(1440):NEXT(4311$);

4311$         ASSIGN:        Create for receiving a shift1 c4.NumberOut=Create for receiving a shift1 c4.NumberOut + 1
                             :NEXT(333$);


;
;
;     Model statements for module:  Create 106
;

4314$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sa1ship# c4:MinutesToBaseTime(1440):NEXT(4315$);

4315$         ASSIGN:        Create for shipmenta shift1 c4.NumberOut=Create for shipmenta shift1 c4.NumberOut + 1:NEXT(360$);


;
;
;     Model statements for module:  Create 107
;

4318$         CREATE,        1,MinutesToBaseTime(0.0001),Entity ra1rec# c5:MinutesToBaseTime(1440):NEXT(4319$);

4319$         ASSIGN:        Create for receiving a shift1 c5.NumberOut=Create for receiving a shift1 c5.NumberOut + 1
                             :NEXT(395$);


;
;
;     Model statements for module:  Create 108
;

4322$         CREATE,        1,MinutesToBaseTime(0.0001),Entity sa1ship# c5:MinutesToBaseTime(1440):NEXT(4323$);

4323$         ASSIGN:        Create for shipmenta shift1 c5.NumberOut=Create for shipmenta shift1 c5.NumberOut + 1:NEXT(422$);


;
;
;     Model statements for module:  Create 109
;

4326$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sc2ship# c1:MinutesToBaseTime(1440):NEXT(4327$);

4327$         ASSIGN:        Create for shipment c shift2 c1.NumberOut=Create for shipment c shift2 c1.NumberOut + 1:NEXT(120$);


;
;
;     Model statements for module:  Create 110
;

4330$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sc2ship# c2:MinutesToBaseTime(1440):NEXT(4331$);

4331$         ASSIGN:        Create for shipment c shift2 c2.NumberOut=Create for shipment c shift2 c2.NumberOut + 1:NEXT(250$);


;
;
;     Model statements for module:  Create 111
;

4334$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sc2ship# c3:MinutesToBaseTime(1440):NEXT(4335$);

4335$         ASSIGN:        Create for shipment c shift2 c3.NumberOut=Create for shipment c shift2 c3.NumberOut + 1:NEXT(316$);


;
;
;     Model statements for module:  Create 112
;

4338$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sc2ship# c4:MinutesToBaseTime(1440):NEXT(4339$);

4339$         ASSIGN:        Create for shipment c shift2 c4.NumberOut=Create for shipment c shift2 c4.NumberOut + 1:NEXT(378$);


;
;
;     Model statements for module:  Create 113
;

4342$         CREATE,        1,MinutesToBaseTime(600.0001),Entity sc2ship# c5:MinutesToBaseTime(1440):NEXT(4343$);

4343$         ASSIGN:        Create for shipment c shift2 c5.NumberOut=Create for shipment c shift2 c5.NumberOut + 1:NEXT(440$);









